【JavaSE】接口

前言：为方便讲解一个java文件写多个类或多个接口，平时我们应该一个接口或一个类一个java文件。

1. 接口概念

在现实生活中，接口的例子比比皆是，比如：笔记本上的USB口。
电脑的USB口上，可以插：U盘、鼠标、键盘…所有符合USB协议的设备

接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

2. 接口的定义及使用

1.定义方法

接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。

public interface IPort {
	//成员变量
	//成员方法
}
1
2
3
4

1. 创建接口时, 接口的命名一般以大写字母 I 开头.
2. 接口的命名一般使用 “形容词” 词性的单词.

2.接口中的成员方法，只能是抽象方法(被default修饰及静态方法除外)，所以的方法 都默认是 public abstract

interface IPort {
    public abstract void method1();		//固定为这个
    public void method2();
    abstract void method3();
    void method4();
}
1
2
3
4
5
6

以上方法全都默认为 public abstract 修饰，即默认为抽象方法，不管你有没有写，这里推荐第四种写法，简洁。

当使用 private 等修饰时报错

3. 接口中的成员变量默认是 public static final --静态常量

interface IPort {
    public static final int a = 10;
    int b =20;
    public int c =30;
    static int d =30;
    final int e = 30;
}
1
2
3
4
5
6
7

当然写法还要很多，这里就不多说了，只要记住默认是 public static final。

在定义时必须赋值。且不能修改，不然报错

4. 想要具体实现接口中的方法，需要用 default 修饰，变为默认方法

我们知道抽象方法里不能实现具体的东西，不然会报错。

5. 接口中的静态方法可以有具体的实现

interface IPort {
    public default void method1() {
        System.out.println("默认方法");
    }
    
    public static void method2() {
        System.out.println("静态方法");
    }
}
1
2
3
4
5
6
7
8
9

6. 接口中的成员变量和成员方法访问修饰限定符只能是 public ，不写时也是默认为 public。

7. 一个普通类可以通过 implements 来实现接口。

interface IPort {
    public default void method1() {
        System.out.println("默认方法");
    }

    public static void method2() {
        System.out.println("静态方法");
    }
    void method3();
}
//实现IPort接口
public class A implements IPort{
	//必须重写接口的抽象方法
    @Override
    public void method3() {
        System.out.println("必须重写接口中的抽象方法");
    }
    //按需重写默认方法
    @Override
    public void method1() {
        System.out.println("按需重写default方法");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

注意：

1. 当一个普通类实现一个接口时，必须重写接口的抽象方法，默认方法可以按需进行重写。
2. 如果一个实现类实现了多个接口，并且这些接口中有两个接口的默认方法是一样的，那么就必须在实现类中重写默认方法。
3. 因为接口的访问修饰限定符都是默认是 public，所以在重写接口方法时，必须使用 public 修饰。

8. 和抽象类一样，接口不能进行实例化，只能通过向上转型进行实例化。

向上转型实例化

interface IShape {
    void draw();
}
class Circle implements IShape {
    @Override
    public void draw() {
        System.out.println("⚪");
    }
}

public class Test1 {
    public static void main(String[] args) {
        IShape iShape = new Circle();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

访问draw时也会发生动态绑定，多态思想。

注意：子类和父类之间是extends继承关系，类与接口之间是implements实现关系。

总结：

1. 接口中的成员方法，只能是抽象方法(被default修饰及静态方法除外)，所以的方法都默认是 public abstract。
2. 接口中的成员变量默认是 public static final --静态常量。
3. 想要具体实现接口中的方法，需要用default修饰，变为默认方法。
4. 接口中的静态方法可以有具体的实现。
5. 接口中的成员变量和方法访问修饰限定符只能是 public ，不写时也是默认为 public，所以当一个类实现接口时，重写接口的方法时只能用public 修饰。
6. 一个普通类可以通过implements 来实现接口。
7. 和抽象类一样，接口不能进行实例化，只能通过向上转型进行实例化。
8. 当抽象类实现接口时，可以不重写接口的抽象方法，普通类实现接口必须重写接口抽象方法。
9. 接口中不能有静态代码块和构造方法。
10. 接口虽然不是类，但是接口编译完成后生成的字节码文件后缀也是 .class文件

3. 实现多个接口

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。

class Animal {
    public String name;
    
    public void eat() {
        System.out.println(this.name + "正在吃饭");
    }
    public Animal(String name) {
        this.name = name;
    }
}
class Dog extends Animal {
    public void bark() {
        System.out.println(this.name + "：汪汪汪");
    }
    public Dog(String name) {
        super(name);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

我们知道狗不仅能吃东西，还可以跑，但是动物有飞的、游泳的、跑的，如果把飞的和游泳的写在动物类中被使狗类继承了就合适了。

所以我们可以定义三个接口，表示三个功能，供给能跑或飞或游泳的一类东西使用。

package blogs4;

//跑
interface IRunning {
    void run();
}
//飞
interface IFlying {
    void fly();
}
//游
interface ISwimming {
    void swim();
}
//动物类
abstract class Animal {
    public String name;

    public abstract void eat();

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

//狗类
class Dog extends Animal implements IRunning{

    public Dog(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println(this.name + "正在吃狗粮");
    }
    @Override
    public void run() {
        System.out.println(this.name + " is dog 正在跑");
    }

}
//鸭子
class Duck extends Animal implements IRunning, ISwimming,IFlying{

    public Duck(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println(this.name + "正在吃小鱼");
    }
    @Override
    public void run() {
        System.out.println(this.name + " is duck 正在跑");
    }

    @Override
    public void fly() {
        System.out.println(this.name + "正在天上飞");
    }

    @Override
    public void swim() {
        System.out.println(this.name + "正在水里游泳");
    }
}

public class Test1 {
    public static void run(IRunning iRunning) {
        iRunning.run();
    }
    public static void main(String[] args) {
        IRunning dogRun = new Dog("喜喜");
        IRunning duckRun = new Duck("小黄");
        run(dogRun);
        run(duckRun);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

从上面可以看到，狗是动物，同时实现了跑的功能，而鸭子是动物同时可以进行跑、飞、游的动作。

一个类，可以继承抽象类，同时实现多个接口。每个接口之间使用逗号来分割。

同时不一定是动物可以跑，机器人也可以跑

所以使用接口时，可以更加灵活的实例化

继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性

• 狗是一种动物, 具有会跑的特性。
• 青蛙也是一种动物, 既能跑, 也能游泳。
• 鸭子也是一种动物, 既能跑, 也能游, 还能飞。

这样设计有什么好处呢? 时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型,而只关注某个类是否具备某种能力。

如上面的，会跑的不一定是动物还可以是机器人

4. 接口的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。

接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字。

好的，到这里本章节就结束了，如发现有错误，请各位大佬及时指出。