Java练习>接口>>继承父类并实现多个接口

使用接口的时候，需要注意：

1. 接口是没有静态代码块或者构造方法的。

2. 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。

   格式：public class MyInterface implements MyInterfaceA,MyInterfaceAB{

       // 覆盖重写所有抽象方法

    }

3. 如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一个即可。

4. 如果实现类有没覆盖重写所有接口中的所有抽象方法，那么实现类就必须是一个抽象类

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

6.一个类如果直接父类当中的方法，和接口当中的默认方法，产生了冲突，优先用父类当中的方法。

实例如下：

创建一个接口类A：

package JieKou;

// 接口类A

public interface MyInterfaceA {

    //错误写法！接口中不能有静态代码块
//    static {
//
//    }

    //接口中不能有构造方法
//    public MyInterfaceA(){
//
//    }

    public abstract void methodA(); // 抽象方法

    public abstract void methodAbs(); // 抽象方法

    public abstract void methodAbsA(); // 抽象方法

    public default void menthodDefault(){
        System.out.println("默认方法AAA");
    }
}

创建一个接口类B：

package JieKou;

// 接口类B

public interface MyInterfaceB {

    //错误写法！接口中不能有静态代码块
//    static {
//
//    }

    //接口中不能有构造方法
//    public MyInterfaceA(){
//
//    }

    public abstract void methodB(); // 抽象方法

    public abstract void methodAbs(); // 抽象方法

    public default void menthodDefault(){
        System.out.println("默认方法BBB");
    }
}

创建一个实现类impl：

package JieKou;

// 实现类impl

//如果实现类有没覆盖重写所有接口中的所有抽象方法，那么实现类就必须是一个抽象类
//一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。格式：用分号隔开
public abstract class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB {
    @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 menthodDefault() {
        System.out.println("对多个接口当中冲突的默认方法进行了覆盖重写");
    }
}

创建一个接口类MyInterface：

package JieKou;

//接口类MyInterface

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

创建一个父类Fu：

package JieKou;

//父类

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

创建一个子类使用父类：

package JieKou;

//未报错 说明优先于父类中的构造方法
public class Zi extends Fu implements MyInterface{

}

使用实用类和子类：

package JieKou;

public class Demo01Interface {
    public static void main(String[] args) {
//        一个类如果直接父类当中的方法，和接口当中的默认方法，产生了冲突，优先用父类当中的方法。
        Zi zi = new Zi();
        zi.method();
        System.out.println("============================================");

        MyInterfaceImpl impl = new MyInterfaceImpl() {
            @Override
            public void methodAbsA() {
                System.out.println("因为MyInterfaceImpl实现类是：抽象类，所有接口中的方法可以不完全重写");
            }
        };

        impl.methodA();
        impl.methodB();
        impl.menthodDefault();
        impl.methodAbsA();

    }
}

以上代码运行结果：

父类方法
============================================
覆盖重写了A方法
覆盖重写了B方法
对多个接口当中冲突的默认方法进行了覆盖重写
因为MyInterfaceImpl实现类是：抽象类，所有接口中的方法可以不完全重写