认识Java的第十一天（中）——接口的多实现

接口的多实现

在继承体系中，一个类只能继承一个父类，而对于接口来，那么一个类可以实现多个接口，这个就是我们的接口的多实现。
class 类名 [extends 父类] implements 接口1,接口2,接口3{
//重写接口中的抽象方法【必须要重写】
//重写接口中的默认方法【选择性去重写】
}

抽象方法

接口中，有多个抽象方法，实现类必须重写所有的抽象方法，如果抽象方法有重名的现象，只能实现一次就可以
定义多个接口

public interface A {
    //定义一些抽象的方法
    public abstract void showA();
    public abstract void show();
}

public interface B {
    //抽象方法
    public abstract void showB();
    public abstract void show();
}

public class C implements A,B{
    @Override
    public void showA() {
        System.out.println("我是showA");
    }

    @Override
    public void showB() {
        System.out.println("我是showB");
    }

    @Override
    public void show() {
        System.out.println("我是show方法");
    }
}

public class Demo {
    public static void main(String[] args) {
        C c=new C();
        c.show();
        c.showA();
        c.showB();
    }
}
/*我是show方法
我是showA
我是showB*/

默认方法

接口中，有多个默认方法时，实现类都可以继承使用，如果默认方法有重名的，必须重写一次。

public interface A {
    public default void show(){
        System.out.println("我们接口a中的show");
    }
    public default void show1(){
        System.out.println("我是接口a中的show1");
    }
}

public interface B {
    public default void show(){
        System.out.println("我们接口b中的show");
    }
    public default void show2(){
        System.out.println("我是接口b中的show1");
    }
}

public class C implements A,B{
    @Override
    public void show() {
        System.out.println("我是showA");
    }
}

public class Demo {
    public static void main(String[] args) {
        C c=new C();
        c.show();
        c.show1();
        c.show2();
    }
}
/*结果：我是showA
我是接口a中的show1
我是接口b中的show1*/

静态方法

接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口去访问静态方法。

public interface A {
    public static void mathod(){
        System.out.println("我是接口a中的静态方法");
    }
}

public interface B {
    public default void show() {
    public static void mathod() {
        System.out.println("我是接口b中的静态方法");
    }
}

public class Demo {
    public static void main(String[] args) {
        A.mathod();
        B.mathod();
    }
}
//结果：我是接口a中的静态方法
//我是接口b中的静态方法

接口的多继承

一个接口可以继承另外一个或者多个接口，这和类之间的继承相似，接口的继承也使用我们的extends关键字，子接口继承父接口的方法，如果父接口中的默认方法有重名，那么子接口需要重写一次。

public interface A {
//默认方法
    public default void  methodA(){
        System.out.println("我是a接口中的方法");
    }
}

public interface E {
    public default void methodA(){
        System.out.println("EEEEE");
    }
}

public interface D extends A,E{
    @Override
    default void methodA() {
        System.out.println("DDDDDD");
    }
}

其他成员特点

1、接口中的，无法定义成员变量，但是可以定义常量，其值不能改变，默认使用public static final修饰
2、接口中，没有构造方法，不能创建对象
3、接口中的，没有静态代码块。

优先级的问题

当一个类中，既继承了一个父类，又实现了多个接口，父类中的方法和接口的默认方法重名，子类就会就近选择执行父类的成员方法。

public interface A {
//默认方法
    public default void  methodA(){
        System.out.println("我是a接口中的方法");
    }
}

public class C {
    public  void  methodA(){
        System.out.println("我是c接口中的方法");
    }
}

public class B extends C implements A{

}

public class Demo {
    public static void main(String[] args) {
        B b=new B();
        b.methodA();
    }
}
/*结果：我是c接口中的方法
*/