老王学java 七周第三天

接口和接口之间的多继承关系：
1,类与类之间是单继承的。直接父类只有一个。
2，类与接口之间是多实现的，一个类可以实现多个接口。
3，接口与接口之间是多继承的。

注意事项：
1，多个父接口当中的抽象方法如果重复，没关系。
2，多个父接口当中的默认方法如果重复。那么子接口必须默认方法的覆盖重写，「而且带着default关键字」

创建接口A

public interface MyInterfaceA {
	
	//创建一个 抽象方法
	
	public abstract void metodA();
   // 和B 一样的抽象方法
	 public abstract void metodCommon();
	 
	 
	 //默认方法 和B 的默认方法重复
	 public default void methodDefault(){
		 System.out.println("AAA");
	 }
}

创建接口B

public interface MyInterfaceB {
	
		//创建一个 抽象方法
		
		public abstract void metodB();
        //和A一样的抽象方法
	    public abstract void metodCommon();
	    
	    
	    默认方法 和A的默认方法重复
	    public default void methodDefault(){
			 System.out.println("BBB");
	    }
}

创建子接口

这个子接口当中有几个方法？答：4个。
 methodA 来源于接口A
 methodB 来源于接口B 
 methodCommon 同时来源于接口A 和B 
 method 来源与我自己
  
  
  */
public interface MyInterface extends MyInterfaceA, MyInterfaceB{
	
	public abstract void method();
	
	
	
	
	//那么继承的的子接口内必须默认重写，
	@Override
	public default void methodDefault(){
		
	}

}

证明它有四个抽象方法

public class MyInterfaceImpl implements MyInterface{

	@Override
	public void metodB() {
		
		
	}

	@Override
	public void metodA() {
		
		
	}

	@Override
	public void metodCommon() {
		
		
	}

	@Override
	public void method() {
		
		
	}

	
}

多态性：

多态的格式与使用：
代码当中体现多态性，其实就是一句话：父类引用指向子类对象
格式：
分类名称 对象名 = new 子类名称（）；
或者：
接口名称 对象名 = new 实现类名称（）；

public class Demo01Multi {

	public static void main(String[]args){
		
		//使用多态的写法
		//左侧父类的引用，指向了右侧子类的对象
		Fu obj = new Zi();
		
		
		obj.method();//子类方法
		obj.methodFu();//父类方法
	}
}

父类

public class Fu {
	
	public void method(){
		System.out.println("父类方法");
	}
	public void methodFu(){
		System.out.println("父类特有方法");
	}

}

子类

public class Zi extends Fu{

	@Override//覆盖重写
	public void method(){
		System.out.println("子类方法");
		
	}
}

多态中成员变量的使用特点：

访问成员变量有两种方式：
1，直接通过对象名称访问成员变量： 看等号左边是谁，优先用谁，没有则向上找
2，间接通过成员方法访问成员变量： 看该方法属于谁，优先用谁，没有则向上找。

public class Demo01MultiField {
	public static void main(String[]args){
		//使用多态的写法，父类引用指向子类对象
		Fu obj = new Zi();
		System.out.println(obj.num);//父类的10
//		System.ouot.println(obj.age);//父类当中没有age，往上找，只要最高的estends Object,最高祖宗类。
									//祖宗类也没age，所有错误。
		System.out.println("==============");
		
		//子类没有覆盖重写，就是父：10
		//子类如果覆盖重写，就是子：20
		obj.showNum();
		
	}

}

父类：

public class Fu/* extends Object*/{
 
	int num = 10;
	public void showNum(){
		System.out.println(num);
	}
}

子类：

public class Zi extends Fu {
	
	int num = 20;

	int age = 16;
	
	@Override
	public void showNum(){
		System.out.println(num);
	}
	
}

多态中成员方法的使用特点：
在多态的代码当中：成员方法的访问规则是：
看new的是谁，就优先有谁，没有则向上找。

口诀：
编译看左边，运行看右边。

对比一下：
成员变量：编译看左边，运行还看左边。
成员方法：编译看左边，运行看右边。

public class Demo02MultiMethod {
	
	public static void main(String[]args){
		Fu obj = new Zi();//多态
		
		obj.method();//父子都要，但是new的是Zi所以就优先用子。
		obj.methodFu();//子类没有，父类有，向上找到父类
		
		
		//编译看左，左边是Fu，Fu当中没有methodZi方法，所有编译报错。
//		obj.methodZi();//错误写法
	}

}

父类

public class Fu/* extends Object*/{
 

	
	public void method(){
		System.out.println("父类方法");
	}
	
	public void methodFu(){
		System.out.println("父类特有方法");
	}
	
}

子类

public class Zi extends Fu {
	
	
	@Override
	public void method(){
		System.out.println("子类方法");
	}
	public void methodZi(){
		System.out.println("子类特有方法");
	}
}

使用多态的好处：