接口

使用关键字interface 定义，是和类同级别的结构
实例：模拟USB的接口逻辑
面试题：区分抽象类和接口

内部结构

可以声明：
属性：必须使用public static final修饰（可以省略）
方法：
jdk8之前：声明抽象方法，修饰为public abstract （可以省略）
jdk8:声明静态方法、默认方法
jdk9:声明私有方法

interface Flyable{  //接口
    //全局常量
    public static final int MIN_SPEED = 0;
    //可以省略public static final
    int MAX_SPEED = 7900;
    //方法可以省略public abstract 声明
    void fly();
}

使用规则

类实现接口

class A extends SuperA implements B,C{}

A是SuperA的子类，是B和C的实现类，表现为单继承和多实现，一定程度上就弥补了类的单继承的局限性

和其他结构的联系

类和接口

类必须将实现的接口中的所有的抽象方法都重写（或实现），方可实例化。否则，此实现类必须声明为抽象类

接口和接口

继承关系，且可以多继承

interface AA{
    void method1();
}
interface BB{
    void method2();
}
interface CC extends AA,BB{ //接口可以多继承

}
class DD implements CC{
    @Override
    public void method1() {
    }
    @Override
    public void method2() {
    }
}

接口的多态性

public class InterfaceTest {
    public static void main(String[] args) {
        //接口的多态性
        Flyable f1 = new Bullet();
        f1.fly();
    }
}
interface Flyable{  //接口
    //全局常量
    public static final int MIN_SPEED = 0;
    //可以省略public static final
    int MAX_SPEED = 7900;
    //方法可以省略public abstract 声明
    void fly();
}
interface Attackable{ //接口
    public abstract void  attack();
}
class Bullet implements Flyable,Attackable{// 多实现
    @Override
    public void fly() {
        System.out.println("让子弹飞一会儿");
    }
    @Override
    public void attack() {
        System.out.println("子弹可以击穿身体");
    }
}

创建接口的实现类

除了创建对象实现接口和使用匿名对象实现接口外，匿名类也可以实现接口

Computer computer =  new Computer();
// 创建接口实现类的对象
Printer printer = new Printer();
computer.transferData(printer);

// 创建接口实现类的匿名对象
computer.transferData(new Camera());

// 创建接口匿名实现类的对象
USB usb1 = new USB(){
	public void start(){
		System.out.println("U盘开始工作");
	}
	public void stop(){
		System.out.println("U盘结束工作");
	}
};
computer.transferData(usb1);

接口没有构造器，所以需要在声明的后面实现接口中规定的方法
进一步，可以创建匿名接口的匿名对象

// 创建接口匿名实现类的匿名对象
computer.transferData(new USB() {
	public void start() {
		System.out.println("U盘开始工作");
	}
	public void stop() {
		System.out.println("U盘结束工作");
	}
});

JDK8之后的新特性

jdk8:声明静态方法、默认方法
jdk9:声明私有方法
定义接口NCA

public interface NCA {
    public static void fun1(){
        System.out.println("fun1");
    }
    public default void fun2(){
        System.out.println("fun2");
    }
    public default void fun3(){
        System.out.println("fun3");
    }
}

定义接口NCB

public interface NCB {
    public default void fun3(){
        System.out.println("fun3");
    }
}

实现类SubClass

public class SubClass implements NCA, NCB {
    @Override
    public void fun2() {
        System.out.println("fun2-SubClass");
    }
    @Override
    public void fun3() {
        System.out.println("fun3-SubClass");
    }
    public void fun4() {
        System.out.println("fun4-SubClass");
    }
    public void fun() {
        fun3();
        NCA.super.fun3();
        NCB.super.fun3();
    }
}

接口中声明的静态方法只能由接口调用，不能由实现类调用

NCA.fun1();

接口中声明的默认方法可以被实现类继承，没有重写时默认调用接口中的方法

SubClass s1 = new SubClass();
s1.fun2();

实现类同时实现两个接口时，若两个接口中有同名同参数的默认方法，实现类中必须重写该方法

@Override
public void fun3(){
	System.out.println("fun3-SubClass");
}

实现类调用接口的已经重写的方法

NCA.super.fun3();
NCB.super.fun3();