接口+多态+对象转型及内部类(1)

布满荆棘的人生 2024-04-09 02:04 96阅读 0赞

## 接口+多态+对象转型及内部类(1) ##

### 一、接口 ###

#### 1.含义：接口是特殊的抽象类，接口中只能有静态常量和抽象方法 ####

#### 2.应用场景：指定标准 ####

#### 3.注意： ####

##### 1.接口中的方法默认添加public abstract #####

##### 2.接口中的属性默认添加public static final #####

##### 3.JDK1.8新特性：接口中可以默认方法和静态方法 #####

#### 需求：指定学生管理系统的标准 ####

public class Test01 {
        
    
    		public static void main(String[] args) {
        
    			
    			StudentManagerSystem sms = new StudentManagerSystem();
    			sms.add(new Student("嬴政",'男',40,"100","001"));
    			sms.delete("100", "001");
    			Student student = sms.query("100", "001");
    			System.out.println(student);
    			
    			sms.defaultMethod();
    			
    			//直接使用接口名调用接口中的静态方法
    			IStudentManagerSystem.staticMethod();
    		}
    }

//学生管理系统的实现类
    public class StudentManagerSystem implements  IStudentManagerSystem{
        
    
    	@Override
    	public void add(Student stu) {
        
    		// TODO Auto-generated method stub
    		
    	}
    
    	@Override
    	public void expansion() {
        
    		// TODO Auto-generated method stub
    		
    	}
    
    	@Override
    	public void delete(String classId, String id) {
        
    		// TODO Auto-generated method stub
    		
    	}
    
    	@Override
    	public Student query(String classId, String id) {
        
    		// TODO Auto-generated method stub
    		return null;
    	}
    
    }

public class Student {
        
    
    		private String name;
    		private char sex;
    		private int age;
    		private String classId;
    		private String id;
    		
    		public Student() {
        
    		}
    
    		public Student(String name, char sex, int age, String classId, String id) {
        
    			super();
    			this.name = name;
    			this.sex = sex;
    			this.age = age;
    			this.classId = classId;
    			this.id = id;
    		}
    
    		public String getName() {
        
    			return name;
    		}
    
    		public void setName(String name) {
        
    			this.name = name;
    		}
    
    		public char getSex() {
        
    			return sex;
    		}
    
    		public void setSex(char sex) {
        
    			this.sex = sex;
    		}
    
    		public int getAge() {
        
    			return age;
    		}
    
    		public void setAge(int age) {
        
    			this.age = age;
    		}
    
    		public String getClassId() {
        
    			return classId;
    		}
    
    		public void setClassId(String classId) {
        
    			this.classId = classId;
    		}
    
    		public String getId() {
        
    			return id;
    		}
    
    		public void setId(String id) {
        
    			this.id = id;
    		}
    		
    		
    		@Override
    		public boolean equals(Object obj) {
        
    			if (this == obj) {
        
    				return true;
    			}
    			Student stu = (Student) obj;
    			if ((this.classId.equals(stu.classId)) && (this.id.equals(stu.id))) {
        
    				return true;
    			}
    			return false;
    		}
    		
            @Override
            public String toString() {
        
            return "Student [name=" + name + ", sex=" + sex + ", age=" + age + ", classId=" + classId + ", id=" + id + "]";
            }
    }

//学生管理系统的接口 -- 制定标准
    public interface IStudentManagerSystem {
        
    
    		int MAX_CAPACITY = 1000;
    		
    		/**
    		 * 添加学生
    		 * @param stu
    		 */
    		public void add(Student stu);
    		
    		/**
    		 * 扩容
    		 */
    		public void expansion();
    		
    		/**
    		 * 删除学生
    		 * @param classId
    		 * @param id
    		 */
    		public void delete(String classId,String id);
    		
    		/**
    		 * 查询学生
    		 * @param classId
    		 * @param id
    		 * @return
    		 */
    		public Student query(String classId,String id);
    		
    		//默认方法
    		default void defaultMethod(){
        
    			System.out.println("接口中的默认方法");
    		}
    		
    		//静态方法
    		public static void staticMethod() {
        
    			System.out.println("接口中的静态方法");
    		}
    }

### 二、深入接口 ###

#### 1.类 - 接口的关系： ####

##### 1.类 - 类：单继承 #####

##### 2.类 - 接口：多实现 #####

##### 3.接口 - 接口：多继承 #####

#### 2.面试题： ####

##### 1.一个类可以实现多个接口？ #####

> ##### 可以 #####

##### 2.一个接口可以实现多个接口？ #####

> ##### 不可以 #####

##### 3.接口里面的方法不一定都是抽象的？ #####

> ##### JDK1.8开始接口中可以有默认方法和静态方法 #####

##### 4.接口解决了类的单继承问题？ #####

> ##### 是的 #####

##### 5.一个类是否可以继承一个类并同时实现多个接口？ #####

> ##### 可以 #####

##### 6.接口可以new对象？ #####

> ##### 不可以，创建的是匿名内部类的对象 #####

public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		//创建的是匿名内部类的对象
    		//底层步骤：
    		//1.创建匿名实现类实现I1接口中的抽象方法
    		//2.创建匿名实现类的对象
    		//3.将匿名实现类对象的内存地址赋值给接口的引用
    		I1 i1 = new I1(){
        
    			@Override
    			public void i1Method() {
        
    				
    			}
    		};
    	}
    }

//一个类继承一个类，实现多个接口
    public class A extends Object implements I1,I2,I3{
        
    
    	@Override
    	public void i4Method() {
        
    		// TODO Auto-generated method stub
    		
    	}
    
    	@Override
    	public void i5Method() {
        
    		// TODO Auto-generated method stub
    		
    	}
    
    	@Override
    	public void i3Method() {
        
    		// TODO Auto-generated method stub
    		
    	}
    
    	@Override
    	public void i2Method() {
        
    		// TODO Auto-generated method stub
    		
    	}
    
    	@Override
    	public void i1Method() {
        
    		// TODO Auto-generated method stub		
    	}
    }

public interface I1 {
        
    	public void i1Method();	
    }

public interface I2 {
        
    	public void i2Method();
    }

public interface I3  extends I4,I5 {
        
    	public void i3Method();
    }

public interface I4 {
        
    	public void i4Method();
    }

public interface I5 {
        
    	public void i5Method();
    }

### 三、类的多态 ###

#### 1.需求：老师骑着自行车上班 ####

##### 分析：老师类、自行车类 #####

#### 2.需求升级：自行车 --> 小汽车 ####

#### 1.步骤： ####

##### 1.创建Car类，编写start()和stop() #####

##### 2.在原有Teacher类的基础上再添加open()和close() --> 修改原有类的结构 #####

#### 2.设计模式 vs 设计原则 ####

##### 1.设计模式：前人给我们总结的步骤，再一定需求下，使用不同的模式 #####

##### 2.设计原则：前人给我们总结的经验，告诉我们什么事情可以干，什么事情不可以干，但是他不会告诉你具体怎么干 #####

#### 3.OCP - 开闭原则（设计原则） ####

##### 1.O - open - 在需求升级时，对创建类是欢迎的（原因：创建类与之前的代码的关联程度低，意味着出现bug的几率小） #####

##### 2.C - close - 在需求升级时，对修改原来的类是拒绝的（原因：原来程序的稳定性较高，修改后可能会出现bug，增加了bug出现的几率） #####

##### 3.P - principle(原则) #####

public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		
    		Teacher t = new Teacher();
    		
    		//类的多态：子类对象指向父类引用
    		//父类引用中存储的是子类对象在堆中开辟的地址
    		
    		Vehicle v = new Plane();
    		t.open(v);
    		System.out.println("欣赏沿途的风景...");
    		t.close(v);
    	}
    }

//交通工具类
    public abstract class Vehicle {
        
    	public abstract void start();
    	public abstract void stop();
    
    }

public class Teacher {
        
    
    	public void open(Vehicle v){
        
    		v.start();
    	}
    	public void close(Vehicle v){
        
    		v.stop();
    	}
    }

public class Plane extends Vehicle {
        
    
    	public void start() {
        
    		System.out.println("飞机：飞");
    	}
    	public void stop() {
        
    		System.out.println("飞机：跳伞");
    	}
    }

public class Car extends Vehicle{
        
    
    	public void start(){
        
    		System.out.println("小汽车：系好安全带，点火，打起步灯，松手刹，挂D档，踩油门");
    	}
    	public void stop(){
        
    		System.out.println("小汽车：踩刹车，拉手刹，熄火，松安全带");
    	}
    }

//自行车
    public class Bike extends Vehicle  {
        
    	
    	public void start(){
        
    		System.out.println("自行车：握好扶手，踩下脚踏板");
    	}
    	public void stop(){
        
    		System.out.println("自行车：捏手刹...");
    	}		
    }

### 四、接口的多态 ###

#### 需求：模拟电脑连接外部设备 ####

public class Test01 {
        
    	public static void main(String[] args) {
        		
    		//接口的多态：实现类对象指向接口的引用
    		//接口的引用中存储的是实现类对象在堆中开辟的地址
    		
    		IUSB usb = new Keyboard();
    		
    		Computer computer = new Computer();
    		
    		computer.connection(usb);
    		
    	}
    }

public class Computer {
        
    	
    	public void connection(IUSB usb){
        
    		usb.use();
    	}
    }

public class Disk implements IUSB {
        
    
    	@Override
    	public void use() {
        
    		System.out.println("硬盘：上传数据、下载数据");		
    	}
    }

public class Keyboard implements IUSB {
        
    
    	@Override
    	public void use() {
        
    		System.out.println("键盘：输入信息");		
    	}
    }

public interface IUSB {
        
    	public void use();
    }

### 五、对象转型 ###

#### 1.多态的优缺点： ####

> ##### 优点：不会违反OCP原则 #####
> 
> ##### 缺点：不能调用子类独有的属性和方法 #####

#### 2.向上转型：子类类型 转 父类类型 ####

*  ##### 可以调用父类非私有化的属性 #####
 *  ##### 可以调用父类非私有化的方法 #####
 *  ##### 可以调用子类重写父类的方法 #####
 *  ##### 注意：向上转型其实就是类的多态 #####

public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		//向上转型
    		
    		Father father = new Son();
    		
    		System.out.println(father.fatherAttr);
    		father.fatherMethod();
    		father.method();
    	}
    }

public class Son extends Father{
        
    	String sonAttr = "子类属性";
    	
    	public void sonMethod(){
        
    		System.out.println("子类方法");
    	}
    	
    	public void method(){
        
    		System.out.println("子类重写父类的方法");
    	}	
    }

public class Father {
        
    
    	String fatherAttr = "父类属性";
    	
    	public void fatherMethod(){
        
    		System.out.println("父类方法");
    	}
    	public void method(){
        
    		System.out.println("父类方法");
    	}
    }

#### 3.向下转型：父类类型 转 子类类型 ####

##### 1.向下转型是不安全的 - ClassCastException #####

public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		
    		//错误示范：会出现ClassCastException(类型转换异常)
    		//注意：不能将一个父类直接转型子类
    		Dog dog =(Dog) new Animal();
    	}
    }

##### 2.向下转型之前，一定是先向上转型后，再向下转型 #####

public class Test02 {
        
    
    	public static void main(String[] args) {
        
    		
    		//向下转型
    		Animal an = new Cat();
    		
    		//向下转型
    		if (an instanceof Dog) {
        
    			Dog dog = (Dog) an;
    			dog.eat();
    		}else if (an instanceof Cat) {
        
    			Cat cat = (Cat) an;
    			cat.shout();
    			
    		}
    	}
    }

public class Animal {
        
    
    }

public class Cat extends Animal{
        
    	public void shout(){
        
    		System.out.println("小猫：喵喵喵~~~");
    	}
    }

public class Dog extends Animal {
        
    	public void eat(){
        
    		System.out.println("小狗：吃骨头~~~");
    	}
    }

### 六、内部类 ###

#### 含义：一个类的内部声明另外一个类 ####

public class Test01 {
        
    }

//外部类
    public class Outter {
        
    	//成员变量
    	public int i1 = 100;
    	//成员内部类：写在类里，方法外
    	public class Inner01{
        }
    	
    	//静态变量
    	public static int i2 = 0;
    	//静态内部类：写在类里，方法外，加上static
    	public static class Inner02{
        }
    	
    	public void method(){
        
    		//局部变量
    		int i3 = 100;
    		//局部内部类：写在方法内
    		class Inner03{
        }
    	}
    	
    }

public interface I1 {
        
    	//接口内部类
    	public class Inner{
        }
    }

#### 1.成员内部类 ####

##### 1.需求：创建成员内部类的对象，调用方法 #####

##### 2.注意： #####

###### 1.先创建外部类对象，再创建成员内部类对象 ######

###### 2.成员内部类可以调用外部类所有的属性 ######

public static void main(String[] args) {
        
    		
    		//创建成员内部类的对象
    		Inner inner = new Outter().new Inner();
    		
    		//调用方法
    		inner.method();
    		
    	}
    }

//外部类
    public class Outter {
        
    	
    	//外部类属性
    	private 		String str1 = "外部类属性1";
    					String str2 = "外部类属性2";
    	protected 		String str3 = "外部类属性3";
    	public 			String str4 = "外部类属性4";
    	final 			String str5 = "外部类属性5";
    	static 			String str6 = "外部类属性6";
    	static final 	String str7 = "外部类属性7";
    
    	//成员内部类
    	public class Inner{
        
    		
    		String str1 = "内部类属性";
    		
    		public void method(){
        
    			System.out.println("成员内部类的method方法：");
    			System.out.println(str1);
    			System.out.println(Outter.this.str1);//获取外部类对象中的str1属性
    			System.out.println(str2);//Outter.this.str2
    			System.out.println(str3);//Outter.this.str3
    			System.out.println(str4);//Outter.this.str4
    			System.out.println(str5);//Outter.this.str5
    			System.out.println(str6);//Outter.str6
    			System.out.println(str7);//Outter.str7
    		}
    	}
    }

#### 2.静态内部类 ####

##### 1.需求：创建静态内部类的对象，调用方法 #####

##### 2.注意： #####

###### 1.直接使用外部类类名调用静态内部类的构造方法去创建对象 ######

###### 2.静态内部类只能调用外部类的静态属性 ######

##### 3.面试题：静态内部类为什么不能调用外部类的成员属性？ #####

> ##### 因为创建静态内部类对象时，不用创建外部类对象，所以外部类的成员属性在内存中得不到体现 #####

import com.qf.outter_inner_03.Outter.Inner;
    
    public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		
    		//创建静态内部类的对象
    		Inner inner = new Outter.Inner();
    		
    		//调用方法
    		inner.method();
    	}
    }

//外部类
    public class Outter {
        
    	
    	//外部类属性
    	private 		String str1 = "外部类属性1";
    					String str2 = "外部类属性2";
    	protected 		String str3 = "外部类属性3";
    	public 			String str4 = "外部类属性4";
    	final 			String str5 = "外部类属性5";
    	static 			String str6 = "外部类属性6";
    	static final 	String str7 = "外部类属性7";
    
    	//静态内部类
    	public static class Inner{
        
    		
    		String str1 = "内部类属性";
    		
    		public void method(){
        
    			System.out.println("静态内部类的method方法：");
    			System.out.println(str1);
    			System.out.println(str6);//Outter.str6
    			System.out.println(str7);//Outter.str7
    		}
    	}
    }