接口新特性

接口组成更新

接口的组成：常量，抽象方法

1. Java8之前

• 常量：public static final
• 抽象方法：public abstract

2. 默认方法（Java8）
3. 静态方法（Java8）
4. 私有方法（Java9）

接口中默认方法（Java8）

接口中默认方法的格式：

• 格式：public default 返回值类型 方法名(参数列表){}

1. 定义一个接口，里面有两个抽象方法，以及一个默认方法：

public interface MyInterface {
    void show1();
    void show2();
    
    //默认方法，有方法体
    //public关键字可以省略
    public default void show3(){
        System.out.println("MyInterface show3");
    }
}

2. 定义接口的实现类，实现接口中的抽象方法：

public class MyInterfaceImpl1 implements MyInterface {
    @Override
    public void show1() {
        System.out.println("1.show1");
    }

    @Override
    public void show2() {
        System.out.println("1.show2");
    }
}

3. 定义测试类：

public class MyInterfaceDemo {
    public static void main(String[] args) {
        //按照多态的方式创建对象并使用
        MyInterface my = new MyInterfaceImpl1();
        my.show1();
        my.show2();
        my.show3();
    }
}

4. 运行结果：

1.show1
1.show2
MyInterface show3

5. 接口中的show3方法也能够在接口的实现类中重写：

public class MyInterfaceImpl1 implements MyInterface {
    @Override
    public void show1() {
        System.out.println("1.show1");
    }

    @Override
    public void show2() {
        System.out.println("1.show2");
    }

    //重写接口中的默认方法show3
    @Override
    public void show3() {
        System.out.println("1.show3");
    }
}

6. 运行测试类：

1.show1
1.show2
1.show3

接口中默认方法的注意事项：

• 接口中的默认方法不是抽象方法，不强制重写。但可以重写，重写时去掉关键字default
• 接口中的默认方法，public关键字可以省略，但default关键字不能省略

接口中静态方法（Java8）

接口中静态方法的格式：

• 格式：public static 返回值类型 方法名(参数列表){}

1. 定义一个接口，里面有抽象方法，默认方法和静态方法：

public interface Inter {
    //抽象方法
    void show1();

    //默认方法
    default void show2(){
        System.out.println("Inter show2");
    }

    //静态方法，public关键字可以省略，static关键字不能省略
    public static void show3(){
        System.out.println("Inter show3");
    }
}

2. 定义一个接口的实现类，并实现接口中的抽象方法：

public class InterImpl implements Inter{
    @Override
    public void show1() {
        System.out.println("InterImpl show1");
    }
}

3. 定义测试类

public class InterDemo {
    public static void main(String[] args) {
        //多态的方式创建对象
        Inter id = new InterImpl();
        id.show1();
        id.show2();
        //接口中的静态方法，只能被接口调用
        Inter.show3();
    }
}

4. 运行结果：

InterImpl show1
Inter show2
Inter show3

接口中静态方法的注意事项：

• 接口中静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
• 接口中静态方法的public关键字可以省略，static关键字不能省略

接口中私有方法（Java9）

接口中私有方法的格式：

• 格式1：private 返回值类型 方法名(参数列表){}
• 格式2：private static 返回值类型 方法名(参数列表){}

1. 定义一个接口，里面有抽象方法，默认方法和静态方法：

public interface Interf {
    //抽象方法
    void show1();

    //默认方法
    default void show2(){
        System.out.println("默认方法开始");
        //默认方法可以调用非静态私有方法，也可以调用静态私有方法
        show4();
        show5();
        System.out.println("默认方法结束");
    }

    //静态方法
    static void show3(){
        System.out.println("静态方法开始");
        //静态方法只能调用静态私有方法
        show5();
        System.out.println("静态方法结束");
    }

    //私有方法1，非静态私有方法
    private void show4(){
        System.out.println("私有方法1");
    }

    //私有方法2，静态私有方法
    private static void show5(){
        System.out.println("私有方法2");
    }
}

2. 定义一个接口的实现类，并实现接口中的抽象方法：

public class InterfImpl implements Interf{
    @Override
    public void show1() {
        System.out.println("InterfImpl show1");
    }
}

3. 定义测试类：

public class InterfDemo {
    public static void main(String[] args) {
        //多态方式创建对象
        Interf i = new InterfImpl();
        i.show1();
        System.out.println("-------------");
        i.show2();
        System.out.println("-------------");

        //接口名调用静态方法
        Interf.show3();
    }
}

4. 运行结果：

InterfImpl show1
-------------
默认方法开始
私有方法1
私有方法2
默认方法结束
-------------
静态方法开始
私有方法2
静态方法结束

接口中私有方法的注意事项：

• 接口中的默认方法，可以调用非静态私有方法，也可以调用静态私有方法
• 静态方法只能调用私有的静态方法