JDK1.8 & 接口的增强

持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的7第天，点击查看活动详情

JDK1.8 之前接口特性

public interface Ceshi{
        //静态常量
        String name=""; 
        //抽象方法
        void todo(String user);
}

JDK1.8 之后接口中可以有 默认方法 和 静态方法

public interface Ceshi {
     //静态常量
    String name="";
    //抽象方法
    void todo(String user);

    //默认方法
    default String getName(){
        return "张三";
    }
    //静态方法
    static String getAge(){
        return "19";
    }
}

这里我们发现接口A中抽象方法更新后 所有实现类都需要去从写这个方法 不利于接口的扩展

public class Test001 {


    public static void main(String[] args) {
        A a =new B();
        A a2 =new C();
    }


}
interface  A{
    void test1();
    
    void test2();
}
class B implements A{
    @Override
    public void test1() {

    }
    //没有重写A中的抽象方法会报错
}
class C implements A{
    @Override
    public void test1() {

    }
    //没有重写A中的抽象方法会报错
}

这里我们可以查看下 Map接口 forEach方法 他也是JDK1.8新增的默认方法

// 当然这个接口中有多个默认方法这个只是其中一个
default void forEach(BiConsumer<? super K, ? super V> action) {
    Objects.requireNonNull(action);
    for (Map.Entry<K, V> entry : entrySet()) {
        K k;
        V v;
        try {
            k = entry.getKey();
            v = entry.getValue();
        } catch(IllegalStateException ise) {
            // this usually means the entry is no longer in the map.
            throw new ConcurrentModificationException(ise);
        }
        action.accept(k, v);
    }
}

下面我们使用下接口默认方法

public class Test001 {


    public static void main(String[] args) {
        A a =new B();
        A c=new C();
        String s = a.todoHello();
        System.out.println("B= " + s);
        String  cs =  c.todoHello();
        System.out.println("C= " + cs);
    }

}
interface  A{
    void test1();
    //默认方法
    default String todoHello(){
        return "hello";
    }
    //默认方法 可以有多个
    default String todoOne(){
        return "todoOne";
    }
}
class B implements A{
    @Override
    public void test1() {

    }

    @Override
    public String todoHello() {
        return "重写Hello";
    }
}
class C implements A{
    @Override
    public void test1() {

    }
}

查看运行结果

B= 重写Hello
C= hello

  可以发现默认方法 在实现类也是可以被重写的，但是不是强制的所有实现类都要去重写,并且可默认方法可以是多个。使得接口更加灵活🥰

下面我们来使用一下 静态方法

public class Test001 {


    public static void main(String[] args) {
        A a =new B();
       A.staticMo();

    }

}
interface  A{
    void test1();
    default String todoHello(){
        return "hello";
    }
    //默认方法
    default String todoOne(){
        return "todoOne";
    }
    //静态方法
    static String staticMo(){
        System.out.println("静态方法被执行");
        return "静态方法";
    }

}
class B implements A{
    @Override
    public void test1() {

    }

    @Override
    public String todoHello() {
        return "重写Hello";
    }
}
class C implements A{
    @Override
    public void test1() {

    }
}

注意： A的静态方法不把被实例出来的a获取到只能通过A获取，当然也不能被实现类去重写。

静态方法被执行

下面我们总结一下静态方法和 默认方法

首先他们都是为了使得接口更加灵活和 高扩展。
默认方法： 通过实例进行调用，可以被实现类重写，可以被继承
静态方法： 通过接口名称调用，不能被继承，也不能被实现类重写。🥰🥰🥰