接口【四】继承父类并实现多个接口

继承父类接口

使用接口时需要注意：
1.接口没有静态代码块或者构造方法的。
先创建一个接口

public interface MyInterface{
	//错误写法1,接口不能有静态代码块
	//static{}
	//错误写法2，接口不能有构造方法
	//public MyInterface(){}
}

2.一个类的直接父类是唯一的（有且只有一个），但一个类可以同时实现多个接口。基本格式：public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB{//覆盖重写所有抽象方法}

创建编写一个MyInterfaceA.java接口文件

public interface MyInterfaceA{
	public abstract void methodA();
}

再创建编写一个MyInterfaceB.java接口文件

public interface MyInterfaceB{
	public abstract void methodB();
}

创建一个实现类MyInterfaceImpl.java

public class MyInterfaceImpl /*extend Object Java中任何一个类都是Object直接或间接子类，可以省略该两个关键字*/ implements MyInterfaceA, MyInterfaceB {
	//快捷方式Alt键+回车，选择Implement methods,再根据需求选择接口的抽象方法来覆盖重写
	@Override
	public void methodA(){
		System.out.println("覆盖重写了A方法")
	}
	
	@Override
	public void methodB(){
		System.out.println("覆盖重写了B方法")
	}
}

3.如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次。
1）MyInterfaceA.java接口文件当中编写：

public interface MyInterfaceA{
	public abstract void methodA();
	public abstract void methodAbs();//这是抽象方法
}

2）MyInterfaceB.java接口文件当中编写：

public interface MyInterfaceB{
	public abstract void methodB();
	public abstract void methodAbs();//这是抽象方法
}

3）MyInterfaceImpl实现类文件当中编写：也就是Alt键+回车选择methodAbs():void

public class MyInterfaceImpl /*extend Object Java中任何一个类都是Object直接或间接子类，可以省略该两个关键字*/ implements MyInterfaceA, MyInterfaceB {
	//快捷方式Alt键+回车，选择Implement methods,再根据需求选择接口的抽象方法来覆盖重写
	@Override
	public void methodA(){
		System.out.println("覆盖重写了A方法")
	}
	
	@Override
	public void methodB(){
		System.out.println("覆盖重写了B方法")
	}
	
	@Override
	public void methodAbs(){
		System.out.println("覆盖重写了AB接口都有的抽象方法")
	}
}

4.如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类必须是一个抽象类。
先创建一个实现类文件

public abstract class MyInterfaceImplimplements MyInterfaceA, MyInterfaceB {
	@override
	public void methodA(){}

	@override
	public void methodAbs(){}
}

5.如果实现类所实现的多个接口当中，存在重复默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
在MyInterfaceA.java接口文件编写：

public interface MyInterfaceA{
	public abstract void methodA();
	
	public abstract void methodAbs();
	
	public default void methodDefault(){
		System.out.println("默认方法AAA")
	}
}

在MyInterfaceB.java接口文件编写：

public interface MyInterfaceA{
	public abstract void methodA();
	
	public abstract void methodAbs();
	
	public default void methodDefault(){
		System.out.println("默认方法BBB")
	}
}

在MyInterfaceImpl.java实现类文件编写：

public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {
	//快捷方式Alt键+回车，选择Implement methods,再根据需求选择接口的抽象方法来覆盖重写
	@Override
	public void methodA(){
		System.out.println("覆盖重写了A方法")
	}
	
	@Override
	public void methodB(){
		System.out.println("覆盖重写了B方法")
	}
	
	@Override
	public void methodAbs(){
		System.out.println("覆盖重写了AB接口都有的抽象方法")
	}

	@override
	public void methodDefault(){
		System.out.println("对多个接口当中冲突的默认方法进行了覆盖重写")
	}
}

在MyInterfaceAbstract.java实现类文件编写：

public abstract class MyInterfaceImplimplements MyInterfaceA, MyInterfaceB {
	@override
	public void methodA(){}

	@override
	public void methodAbs(){}
	//快捷方式Alt键+回车选择Implement methods,再分析哪个默认接口方法冲突就选择哪个
	@Override
	public void methodDefault(){}
}

6.一个类如果直接实现父类中的方法，和接口中的默认方法产生冲突，优先使用父类中的方法。
先new创建编写一个父类

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

创建一个子类

public class Zi extends Fu implements MyInterface{}

接着创建一个接口

public interface MyInterface {
	public default void method(){
		System.out.println("接口的默认方法");
	}
}

在Java中继承由于接口实现
创建尝试使用

public class Demo01Interface{
	public static void main(String[] args){
		Zi zi = new Zi();
		zi.method();
	}
}

最后运行实现

接口间的多继承

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

public interface MyInterfaceA {
	public abstract void methodA();
	public abstract void methodCommon();
}

同理再创建一个MyInterfaceB.java

public interface MyInterfaceB {
	public abstract void methodB();
	public abstract void methodCommon();
}

public interface MyInterface extends MyInterfaceA, MyInterfaceB{
	public abstract void method();
}

//这个子接口有4个方法
//methodA 来源于接口A
//methodB 来源于接口B
//methodCommon 同时来源于接口A和B
//method 来源自己

创建一个实现类验证有4个方法

public class MyInterfaceImpl implements MyInterface {
	//Alt键+回车键选择“Implement methods”,接着全选内容
	@Override
	public  void method(){}
	public  void methodA(){}
	public  void methodB(){}
	public  void methodCommon(){}
}

多个父接口中的抽象方法之间有重复，没有关系，因为抽象方法没有方法
但，如果父类接口默认方法之间有重复，那么子接口必须进行默认方法的覆盖重写，而且需要带有default关键字，它的解决方案如下：

比如MyInterfaceA.java的编码为

public interface MyInterfaceA {
	public abstract void methodA();
	public abstract void methodCommon();

	public default void methodDefault(){
		System.out.println(){"AAA"}
	}
}

同样MyInterfaceB.java的编码为

public interface MyInterfaceB {
	public abstract void methodB();
	public abstract void methodCommon();

	public default void methodDefault(){
		System.out.println(){"BBB"}
	}
}

这里两个父类接口的默认方法被子接口继承，则子接口发生错误，子接口需要在MyInterfaceA.java和MyInterfaceB.java两个接口之间的默认方法选择

public interface MyInterface extends MyInterfaceA, MyInterfaceB{
	public abstract void method();
	//Alt键+回车键选择“Implement methods”,接着冲突的默认方法“methodDefault():void”
	@Override
	default void methodDefault(){}
	//public default void methodDefault(){} //新手写法
}