21、Java 中接口的基本使用

一、接口（Interface）基本使用

📝 接口是一系列方法声明的集合（和抽象类类似）
📝 接口是用来定义规范和标准的
📝 接口通过interface 关键字定义
📝 类可通过implements关键字实现接口中的方法
📝 接口中可定义抽象方法

---

📓 需求：家长请家教教小孩子👶学习（家教👨‍🏫的需求：① 会教画画；② 会教音乐🎼；③ 会教数学）
📓 把需要老师具备的能力抽象为方法（如：teachDrawing、teachMusic、teachMath）
📓 定义一个接口（通过interface关键字），在接口中定义抽象方法（teachDrawing、teachMusic、teachMath）
📓 这个接口是能够当家教老师的人需要遵循的规范、能够当家教老师的人需要遵循的规范标准
📓 认为自己能够胜任家教老师的人需要实现（implements）该接口中所有方法

---

孩子类：

public class Child {
    private String name;
    private Teacherable teacherable;

    public String getName() {
        return name;
    }

    public Child(String name) {
        this.name = name;
    }

    public void setTeacherable(Teacherable teacherable) {
        this.teacherable = teacherable;
    }

    public void study() {
        teacherable.teachDrawing(this);
        teacherable.teachMusic(this);
        teacherable.teachMath(this);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Teacherable 接口：

/**
 * 能够胜任家教老师的人都必须实现 Teacherable 里面的三个方法
 */
public interface Teacherable {
    public abstract void teachDrawing(Child child);

    public abstract void teachMusic(Child child);

    public abstract void teachMath(Child child);
}
1
2
3
4
5
6
7
8
9
10

Student 学生类实现 Teacherable 接口：

public class Student implements Teacherable {
    @Override
    public void teachDrawing(Child child) {
        System.out.println("Student teaches【" + child.getName() + "】画画");
    }

    @Override
    public void teachMusic(Child child) {
        System.out.println("Student teaches【" + child.getName() + "】音乐");
    }

    @Override
    public void teachMath(Child child) {
        System.out.println("Student teaches【" + child.getName() + "】数学");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Robot 机器人类实现 Teacherable 接口：

public class Robot implements Teacherable {
    @Override
    public void teachDrawing(Child child) {
        System.out.println("Robot 教【" + child.getName() + "】画画");
    }

    @Override
    public void teachMusic(Child child) {
        System.out.println("Robot 教【" + child.getName() + "】音乐");
    }

    @Override
    public void teachMath(Child child) {
        System.out.println("Robot 教【" + child.getName() + "】数学");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

TestDemo 测试类：

public class TestDemo {
    public static void main(String[] args) {
        Child qy = new Child("庆医");
        // qy.setTeacherable(new Student());
        qy.setTeacherable(new Robot());
        qy.study();
    }
}
1
2
3
4
5
6
7
8

二、接口中可定义的内容

📓 抽象方法：被abstract修饰的方法
📓 常量：static final
📓 嵌套类型
📓 从 Java8 开始还可以定义：默认方法（被default修饰的方法）、静态方法（被static修饰的方法）

---

📓 上述可以定义的内容都是隐式public的（默认就是public，开发者定义的时候可以省略）
📓 接口中定义的方法默认就是抽象方法（开发者在接口中定义方法的时候可以abstract关键字）
📓 从 Java9 开始可以定义private方法
📓 定义常量的时候可以省略 static 和 final
📓 不能自定义构造方法、不能定义（静态）初始化块
📓 接口没有实例化的说法

public interface Testable {
    int MY_MONEY = 859632587;

    void test1();

    void test2(String description);

    class Demo {

    }

    static void test3() {
        System.out.println("接口中可以定义静态方法");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

三、接口细节

📝 接口是引用数据类型
📝 一个类可以通过implements关键字实现一个或多个接口
📝 实现（implements）接口的类必须实现接口中的所有抽象方法（除非它是一个抽象类）
📝 若一个类实现的多个接口中有相同的抽象方法，该相同的抽象方法只需要被实现一次
📝 extends和implements可以一起使用（implements必须写在extends的后面）

✒️ 当父类和接口中的方法的方法签名一样的时候，返回值类型也必须一样

public class BaseTestDemo {
    public String test(String description) {
        return description;
    }
}
1
2
3
4
5

public interface Testable {
    String test(String description);
}
1
2
3

public class TestDemo extends BaseTestDemo implements Testable {
    public static void main(String[] args) {
        TestDemo testDemo = new TestDemo();
        // Happy
        System.out.println(testDemo.test("Happy"));
    }
}
1
2
3
4
5
6
7

📝 一个接口可以通过extends关键字继承一个或多个接口

✒️ 当多个父接口中的方法的方法签名一样的时候，返回值类型也必须一样

---

📱 结束！如有错误，请不吝赐教！