Java8 接口默认实现方法

接口

user:

public class User {

    private String name;

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

接口类：

public interface InterfaceTest {

    // 接口变量默认修饰符为public static final
    // 所以在接口中声明的变量必须赋初值，且不可变动
    public static final int a = 1;
    int b = 2; // 简写
    User user = new User("wwj"); //简写

    // 接口方法默认修饰符为public static final
    public abstract void fun1();
    void fun2(); //简写

}

测试类：

public class JavaTest implements InterfaceTest {

    // 重写接口方法
    @Override
    public void fun1() {
        System.out.println("JavaTest-fun1");
    }

    // 重写接口方法
    @Override
    public void fun2() {
        System.out.println("JavaTest-fun2");
    }

    public static void main(String[] args) {
        JavaTest javaTest = new JavaTest();

        // 被static修饰为静态变量，用类名.变量方式获得
        System.out.println(InterfaceTest.a); //1
        System.out.println(InterfaceTest.b); //2
        // 其他知识点，final关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。
        // https://blog.csdn.net/u012110719/article/details/46334413
        User user = InterfaceTest.user;
        System.out.println(user);
        user.setName("xxx"); //User{name='wwj'}
        System.out.println(user); //User{name='xxx'}

        // 重写接口方法
        javaTest.fun1(); //JavaTest-fun1
        javaTest.fun2(); //JavaTest-fun2
    }
}

jdk8接口新特性

1. 允许接口中有默认接口方法实现
2. 允许接口有接口静态方法

接口类：

public interface InterfaceTest {

    // 抽象方法
    void abstractFun();

    // 默认实现方法
    default void defaultFun() {
        System.out.println("InterfaceTest-defaultFun");
    }

    // 静态方法
    static void staticFun() {
        System.out.println("InterfaceTest-staticFun");
    }

}

测试类

public class A implements InterfaceTest {

    // 实现接口抽象方法
    @Override
    public void abstractFun() {
        System.out.println("A-abstractFun");
    }

    // 重写接口默认方法
    @Override
    public void defaultFun() {
        System.out.println("A-defaultFun");
    }

    public static void main(String[] args) {
        A a = new A();
        
        a.abstractFun(); //A-abstractFun
        a.defaultFun(); //A-defaultFun
        InterfaceTest.staticFun(); //InterfaceTest-staticFun
    }
    
}

接口的默认方法和父类的方法同名

接口类同上

父类

public class Father {

    public void abstractFun() {
        System.out.println("Father-abstractFun");
    }

    public void defaultFun() {
        System.out.println("Father-abstractFun");
    }

    public static void staticFun() {
        System.out.println("Father-staticFun");
    }

}

测试类

public class JavaTest extends Father implements InterfaceTest {

    @Override
    public void abstractFun() {
        System.out.println("JavaTest-abstractFun");
    }


    public static void main(String[] args) {
        JavaTest javaTest = new JavaTest();
        javaTest.abstractFun(); //JavaTest-abstractFun
        // 父类的优先级高于接口默认方法
        javaTest.defaultFun(); //Father-abstractFun
        InterfaceTest.staticFun(); //InterfaceTest-staticFun
        Father.staticFun(); //Father-staticFun
        JavaTest.staticFun(); //Father-staticFun
    }

}

其他补充