JDK8新特性--接口增强内容

JDK8新特性--接口增强内容

接口初识

JDK8之前的接口内容

interface 接口名{
    静态常量;
    抽象方法;
}

JDK8更新的接口增强内容

interface 接口名{
    静态常量;
    抽象方法;
    静态方法;
    默认方法
}

JDK8增强了接口的默认方法和静态方法，那什么是默认方法和静态方法呢？接下来，我们就进行一下探讨

在探讨之前，我们先来看一下JDK8之前的接口，以及它的一些特性，直接上例子

一开始，我们定义了A接口，然后定义了它的两个实现类B和C，实现类重写了A接口中定义的test1方法，然后通过实现类去调用接口中的方法

package com.features.Interface;

public class demo01 {
    public static void main(String[] args) {
        A b = new B();
        A c = new C();
        // 初始方法调用
        b.test1();
        c.test1();
    }
}

interface A{
    void test1();
}

class B implements A{

    @Override
    public void test1() {
        System.out.println("B中的test1方法");
    }

}

class C implements A{
    @Override
    public void test1() {
        System.out.println("C中的test1方法");
    }
}

这时候，我们有个业务需求，需要在A接口中新增一个test2方法，我们需要在A接口中添加test2方法，然后，它的实现类也需要重写test2方法

package com.features.Interface;

public class demo01 {
    public static void main(String[] args) {
        A b = new B();
        A c = new C();
        // 初始方法调用
        b.test1();
        c.test1();
        // 业务需求，接口扩展的方法调用
        b.test2();
        c.test2();
    }
}

interface A{
    void test1();
    // 因为业务需要，要再添加一个方法，按照下面这种方式添加，则在该接口A的实现类，都需要重写test2方法
    void test2();
}

class B implements A{

    @Override
    public void test1() {
        System.out.println("B中的test1方法");
    }

    @Override
    public void test2() {
        System.out.println("因为业务需要，接口扩展的test2方法，B进行重写");
    }
}

class C implements A{
    @Override
    public void test1() {
        System.out.println("C中的test1方法");
    }

    @Override
    public void test2() {
        System.out.println("因为业务需要，接口扩展的test2方法，C进行重写");
    }
}

这样，我们每次需要扩展接口的方法，它的实现类都需要重写新增的方法，当实现类一多，我们扩展接口方法的代价就很大了，所以，这时候JDK8就新增了默认方法和静态方法来解决这一问题。

接口增强内容--默认方法

默认方法：

1. 在接口中定义，它的实现类默认继承它，也可以重写
2. 通过实例名.方法名来调用

比如说，在上面的基础上，我们在A接口新增了一个test3方法

package com.features.Interface;

public class demo01 {
    public static void main(String[] args) {
        A b = new B();
        A c = new C();
        // 初始方法调用
        b.test1();
        c.test1();
        // 业务需求，接口扩展的方法调用
        b.test2();
        c.test2();
        // 在接口中添加了默认方法，调用方式：实例名.方法名
        b.test3();
        c.test3();
    }
}

interface A{
    void test1();
    // 因为业务需要，要再添加一个方法，按照下面这种方式添加，则在该接口A的实现类，都需要重写test2方法
    void test2();
    // JDK8以后 接口出现了  默认方法 和  静态方法
    // 默认方法
    // 在接口中定义，它的实现类可以默认继承，也可以重写
    public default String test3(){
        System.out.println("JDK8出现的默认方法，接口的实现类默认自动继承");
        return "default method";
    }
}

class B implements A{

    @Override
    public void test1() {
        System.out.println("B中的test1方法");
    }

    @Override
    public void test2() {
        System.out.println("因为业务需要，接口扩展的test2方法，B进行重写");
    }

    @Override
    public String test3() {
        System.out.println("B重写了A接口的默认方法");
        return "Override default method";
    }
}

class C implements A{
    @Override
    public void test1() {
        System.out.println("C中的test1方法");
    }

    @Override
    public void test2() {
        System.out.println("因为业务需要，接口扩展的test2方法，C进行重写");
    }
}

结果：

接口增强内容--静态方法

静态方法：

1. 在接口中定义，它不能被继承也不能被重写
2. 通过接口名.方法名来调用

比如说，在上面的基础上，我们在A接口新增了一个test4方法

package com.features.Interface;

public class demo01 {
    public static void main(String[] args) {
        A b = new B();
        A c = new C();
        // 初始方法调用
        b.test1();
        c.test1();
        // 业务需求，接口扩展的方法调用
        b.test2();
        c.test2();
        // 在接口中添加了默认方法，调用方式：实例名.方法名
        b.test3();
        c.test3();
        // 在接口中添加了静态方法，调用方式：接口名.方法名
        A.test4();

    }
}

interface A{
    void test1();
    // 因为业务需要，要再添加一个方法，按照下面这种方式添加，则在该接口A的实现类，都需要重写test2方法
    void test2();
    // JDK8以后 接口出现了  默认方法 和  静态方法
    // 默认方法
    // 在接口中定义，它的实现类可以默认继承，也可以重写
    public default String test3(){
        System.out.println("JDK8出现的默认方法，接口的实现类默认自动继承");
        return "default method";
    }
    // 静态方法
    // 在接口中定义，它不能被继承也不能被重写
    public static String test4(){
        System.out.println("JDK8出现的静态方法，它不能被继承也不能被重写");
        return "static method";
    }
}

class B implements A{

    @Override
    public void test1() {
        System.out.println("B中的test1方法");
    }

    @Override
    public void test2() {
        System.out.println("因为业务需要，接口扩展的test2方法，B进行重写");
    }

    @Override
    public String test3() {
        System.out.println("B重写了A接口的默认方法");
        return "Override default method";
    }
}

class C implements A{
    @Override
    public void test1() {
        System.out.println("C中的test1方法");
    }

    @Override
    public void test2() {
        System.out.println("因为业务需要，接口扩展的test2方法，C进行重写");
    }
}

结果：

默认方法 vs 静态方法

1. 性质不同

• 默认方法默认被它的实现类继承，它的实现类也可以重写它
• 静态方法不被它的实现类继承，它的实现类也不可以重写它

2. 调用方式不同

• 默认方法通过实例名.方法名调用
• 静态方法通过接口名.方法名调用