【Java】接口

应用场景：当子类中一部分拥有某个行为，另一部分没有该行为，则可以创建一个接口，在接口里面创建该方法，当创建子类时如果有该行为可以实现接口，没有则不需要，如：父类为动物，子类分别为狗，猫，青蛙，兔子等，一部分会游泳，一部分不会游泳，这是就可以创建一个接口来让有需要的子类实现游泳的行为。

一、接口的定义和使用

①接口使用interface关键字来定义，
格式为public interface 接口名{}

②接口和类之间是实现关系，用关键字implements来定义，
格式为：public class 类名 implements 接口名 {}

③接口可以单实现也可以多实现，可以同时实现多个接口
格式为：public class 类名 implements 接口一，接口二 {}
可以与继承关系同时存在
格式为：public class 类名 extends 父类名 implements 接口名{}

④接口中没有构造方法

二、接口中成员的特点

（一）成员变量的特点
①默认为public static final 数据类型 变量名（可以只写数据类型和变量名）
static便于变量的直接调用，final表示成员变量不能被修改

public interface Inter1 {
    public static final int a=10;
}

public class Test implements Inter1{
    public static void main(String[] args) {
        Inter1.a=20;//此时会报错
    }
}

（二）成员方法的特点

①默认为public abstract 数据类型 方法名();
在jdk7之后可以定义其它类型的方法

②如果在实现多个接口时，不同的接口中有重名的方法，在实现类中只会重写一次，表示两个接口中的方法都重写了。

public interface Inter1 {
    public abstract void test1();
    public abstract void test2();
    public abstract void test3();
}

public interface Inter2 {
    public abstract void test3();
    public abstract void test4();
    public abstract void test5();
}

public class Test implements Inter1,Inter2{
    public static void main(String[] args) {

    }
    @Override
    public void test1() {

    }
    @Override
    public void test2() {

    }
    @Override
    public void test3() {

    }
    @Override
    public void test4() {

    }
    @Override
    public void test5() {

    }
}

两个接口中test3的方法重名，在实现类中只重写了一次

三、接口与接口之间的关系

接口与接口之间可以单继承，可以多继承，与类与类之间的关系不同，类与类之间可以单继承，可以多层继承，不能多继承

创建三个接口，并将第三个接口继承接口一和接口二

public interface Inter1 {
    public abstract void test1();
}

public interface Inter2 {
    public abstract void test2();
}

public interface Inter3 extends Inter1,Inter2{
    public abstract void test3();
}

创建接口三的实现类，要对全部的方法进行重写

public class Test implements Inter3{
    public static void main(String[] args) {
    }
    @Override
    public void test1() {
    }
    @Override
    public void test2() {
    }
    @Override
    public void test3() {
    }
}

四、实例

我们现有乒乓球运动员和篮球运动员，乒乓球教练为了出国交流，跟乒乓球相关的人员都要学习英语

乒乓球运动员：姓名，年龄，学打乒乓球，说英语
篮球运动员：姓名，年龄，学打篮球
乒乓球教练：姓名，年龄，教打乒乓球，说英语
篮球教练：姓名，年龄，教打篮球

（一）只采用一层继承关系

创建父类，并定义相关变量

public abstract class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public abstract void work();
}

创建接口，在接口中创建说英语的抽象方法

public interface Speak {
    public abstract void speaking();
}

创建各个子类，将子类都继承父类，并在乒乓球教练和乒乓球运动员的类中都实现接口。

①篮球运动员

public class LP extends Person implements Speak{
    @Override
    public void work() {
        System.out.println("学打篮球");
    }

    @Override
    public void speaking() {
        System.out.println("说英语");
    }
}

②篮球教练

public class LT extends Person{
    @Override
    public void work() {
        System.out.println("教打篮球");
    }
}

③乒乓球运动员

public class PP extends Person implements Speak{
    @Override
    public void work() {
        System.out.println("学打乒乓球");
    }

    @Override
    public void speaking() {
        System.out.println("说英语");
    }
}

④乒乓球教练

public class PT extends Person{
    @Override
    public void work() {
        System.out.println("教打乒乓球");
    }
}

（二）采用两层继承关系

可以在运动员和教练中定义不同的方法名，teach和study，便于区分

public abstract class Sport extends Person{
    public abstract void study();
}

public abstract class Teach extends Person{
    public abstract void teach();
}

五、jdk8之后新增的方法

可以定义非抽象方法，不需要强制重写，也可以在实现类中重写

当实现多个接口时，如果有相同的方法名则会强制重写
格式：public default 返回值类型 方法名{};（public可以省略）

也可以定义静态方法
格式：public static 返回值类型 方法名(){};
直接通过接口名.方法名来调用

①定义接口

public abstract interface Inter4 {
    public abstract void test3();
    
    public default void test4(){
        System.out.println("test");
    }
}

②创建实现类

public class newMethod implements Inter4{
    @Override
    public void test3() {

    }
}

也可以输入接口中的defaul修饰的方法名进行重写

public class newMethod implements Inter4{
    @Override
    public void test3() {

    }

    @Override
    public void test4() {
        Inter4.super.test4();
    }
}

六、jdk9以后新增的方法

接口中可以定义私有方法，只能在接口中使用
当接口中不同的方法有重复的代码时可以把代码提取出来，供接口内的方法使用，而且不被外界调用，用关键字private修饰

public interface Inter6 {
    private static void test1(){
        System.out.println("重复代码");
    }
    public static void test2(){
        test1();
    }
    public static void test3(){
        test1();
    }
}

七、接口多态

当一个方法的参数是接口时，可以传递接口的实现类
①定义接口

public abstract interface Inter4 {
    public abstract void test3();
    public default void test4(){
        System.out.println("test");
    }
}

②创建实现类

public class newMethod implements Inter4{
    @Override
    public void test3() {

    }

    @Override
    public void test4() {
        Inter4.super.test4();
    }

    public void test5(){
        System.out.println("test5");
    }
}

③实现接口多态

public class Test{
    public static void main(String[] args) {
        test1(new newMethod());
    }
    public static void test1(Inter4 inter4){
        inter4.test3();

    }

}

可以使用接口实现类中的方法
多态的使用：https://blog.csdn.net/2202_75462083/article/details/129448908

八、接口的适配器模式

当实现类中不需要重写接口中全部的方法时，可以定义一个中间类，用中间类来实习接口，用测试类来继承实现类，再重写需要的方法
①定义接口

public interface Inter5 {
    public abstract void method1();
    public abstract void method2();
    public abstract void method3();
    public abstract void method4();
}

②定义中间类

public class ZhongJianLei implements Inter5{
    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }

    @Override
    public void method3() {

    }

    @Override
    public void method4() {

    }
}

③创建测试类，使用需要的方法