Java笔记：接口

接口，即Java语言中的一种引用类型，为方法的集合。
接口内部主要封装了一些方法，在JDK7以前包含有抽象方法，JDK8追加了默认方法和静态方法，JDK9追加了私有方法。
接口定义方法类似于类但是使用interface关键字，同时接口也会被编译成 .class 文件。
接口一般不能直接使用，需要一个实现类去实现（implements）接口，然后创建实现类的对象来调用方法。
实现类必须覆盖重写接口中的所有抽象方法，抽象类例外。

定义格式：

public interface 接口名{
    //抽象方法
    //静态方法
    //默认方法
    //私有方法
}

抽象方法：使用abstract关键字修饰，可以省略public 和 abstract关键字，没有方法体，供子类实现覆盖重写使用

public interface 接口名{
    public abstract void 抽象方法名();
}

默认方法：使用default关键字修饰，供实现类对象直接调用或者供实现类覆盖重写，解决接口以后的升级问题
静态方法：使用static关键字修饰，可以通过接口直接调用

public interface 接口名{
    public default void 默认方法名(){
        //方法体；
    }

    public static void 静态方法名(){
        //方法体；
    }
}

私有方法：由private修饰，供接口中的静态方法和默认方法调用，提高代码复用性

public interface 接口名{
    //供默认方法调用
    private void 抽象方法名1(){
    }
    //供静态方法调用
    private static void 抽象方法名2(){
    }
}

基本实现：
实现类与其所实现的接口为实现关系，使用implements关键字。
非抽象实现类：
1.必须重写接口中所有的抽象方法
2.继承接口中的默认方法，也可以覆盖重写它

实现格式：

public class 类名 implements 接口名{
    //重写所有抽象方法
    //重写默认方法（可选）
}

抽象方法使用：
定义接口：

public interface Liveable{
    //定义抽象方法
    public abstract void eat();
    public abstract void drink();
}

定义实现类：

public class Animal implements Liveable{
    //覆盖重写所有抽象方法
    @override
    public void eat(){
        System.out.println("吃饭");
        }
    @override
    public void drink(){
        System.out.println("喝水");
        }
}

定义测试类

public class Test{
    public static void main(String[] args){
        //实例化实现类对象
        Animal animal = new Animal();
        //调用方法
        animal.eat();
        animal.drink();
    }
}

默认方法使用：
继承默认方法
定义接口

public interface Liveable{
        //定义默认方法
        public default void run(){
        System.out.println("奔跑");
    }
}

定义实现类

public class Animal implements Liveable{
}

定义测试类

public class Test{
    public static void main(String[] args){
        Animal animal = new Animal();
        animal.run();
    }
}

重写默认方法
定义接口

public interface Liveable{
    //定义默认方法
    public default void run(){
    System.out.println("奔跑");
    }
}

定义实现类

public class Animal implements Liveable{
    @override
    public void run(){
    System.out.println("快速奔跑");
    }
}

定义测试类

public class Test{
    public static void main(String[] args){
        Animal animal = new Animal();
        animal.run();
    }
}

静态方法的使用
static 与 .class文件相关，只能通过接口名调用，无法通过实现类及其对象调用

定义接口

public interface Liveable{
    public static void jump(){
        System.out.println("跳跃");
    }
}

定义测试类

public class Test{
    public static void main(String[] args){
        //接口名直接调用
        Liveable.jump();
    }
}

私有方法的使用

• 普通私有方法：仅默认方法可以调用

• 私有静态方法：默认方法和静态方法可以调用
  如果接口中多个默认方法和静态方法中含有重复的内容，可以将之提取成私有方法来调用，以提高代码复用性

  定义接口

public interface Liveable{
    public default void method1(){
        methodA();
        methodB();
    }

    public static void method2(){
        methodB();
    }
    private void methodA(){
    }
    private static void methodB(){
    }
}

接口的多实现
不同于类的单继承，一个类可以实现多个接口
实现格式：

public class 类名 extends 父类名 implements 接口名1，接口名2，接口名3……{
    //重写抽象方法
    //重写默认方法（当接口中出现同名默认方法时）
}

抽象方法
实现类中多个接口的抽象方法必须全部重写，同名抽象方法重写一次即可
定义多个接口

public interface interfaceA{
    public abstract void method();
    public abstract void methodA();
}

public interface interfaceB{
    public abstract void method();
    public abstract void methodB();
}

定义实现类

public class C implements interfaceA,interfaceB{
    @override
    public void method(){
        System.out.println("method");
    }
    @override
    public void methodA(){
        System.out.println("methodA");
    }
    @override
    public void methodB(){
        System.out.println("methodB");
    }
}

默认方法
实现类可以继承所实现的多个接口中所有的默认方法，当默认方法名重复时必须覆盖重写
定义多个接口

public interface interfaceA{
    public default void method(){
        System.out.println("method");
    }
    public default void methodA(){
        System.out.println("methodA");
    }
}

public interface interfaceB{
    public default void method(){
        System.out.println("method");
    }
    public default void methodB(){
        System.out.println("methodB");
    }
}

定义实现类

public class C implements interfaceA,interfaceB{
    @override
    public void method(){
        System.out.println("method");
    }
}

静态方法
由于静态方法是直接由接口调用的，所以静态方法的同名并不会引起冲突
优先级问题
当一个类继承的父类中成员方法名与其所实现的接口中默认方法名重名时，会优先调用父类成员方法
定义接口

public interface A{
    public default void method(){
        System.out.println("123");
    }
}

定义父类

public class B{
    public void method(){
        System.out.println("456");
    }
}

定义子类

public class C extends B implements A{
}

定义测试类

public class Test{
    public static void main(String[] args){
        C c = new C();
        c.method();
        //打印结果456
    }
}

接口的多继承
接口能够通过关键字extends继承多个接口，继承父接口中所有的方法，若父接口中有默认方法重名，则子接口必须覆盖重写重名默认方法
其他成员特点

• 接口中，不可以定义成员变量，但可以定义常量，默认用public static final修饰
• 接口中，没有构造方法，不能创建对象
• 接口中，没有静态代码块