接口
# 接口
package com.impl;
/**
* 1. 类是类,接口是接口,他们是同一层次的概念
* 2. 接口中没有构造器
* 3. 接口使用 interface 进行声明
* 4. 在JDK1.8之前 接口中只有两部分内容:常量(public static final)、抽象方法(public abstract)
* 5. 类和接口的关系是实现关系,类实现接口
* 6. 一旦实现一个接口,那么实现类要重写接口中的全部的抽象方法
* 7. 如果没有全部重写抽象方法,那么这个类可以变成一个抽象类
* 8. java只有单继承,但是有多实现;一个类继承其他类,只能直接继承一个父类,但是实现类实现接口,可以实现多个接口
* 9. 接口不能创建对象
*/
public interface TestInterface01 {
// 它默认是知道你前面的修饰符,可以省略不写
// 常量
public static final int NUM = 10;
// 抽象方法
public abstract void a();
public abstract void b(int num);
public abstract int c(String name);
}
interface TestInterface02 {
void d();
}
class Student implements TestInterface01, TestInterface02 {
@Override
public void a() {
System.out.println("1");
}
@Override
public void b(int num) {
System.out.println("2");
}
@Override
public int c(String name) {
return 10;
}
@Override
public void d() {
System.out.println("3");
}
}
class Test {
public static void main(String[] args) {
TestInterface02 t = new Student(); // 接口指向具体的实现类 -> 多态
// 接口访问常量
System.out.println(TestInterface01.NUM);
System.out.println(Student.NUM);
}
}
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
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
# 作用:
定义规则:只是跟抽象类不同的地方,它是接口不是类。‘
接口定义好规则后,实现类负责实现即可。
提示
继承:子类对父类的继承
实现:实现类对接口的实现
案例:
“手机 是不是 照相机”
继承:手机 extends
照相机 -> is-a
的关系,即“手机是一个照相机”,从语义上来看,这不符合。
实现:手机 implements
拍照功能 -> "has-a" 的关系 i,即手机具备照相的功能,这个就比较符合。
案例:飞机,小鸟,风筝,它们都具有飞的功能
- 可以定义一个接口实现飞的方法
- 也可以使用一个父类,它们继承一下,都有飞的功能
提示
具体问题具体分析,具体看选择继承还是接口来完成功能。
# 接口 JDK1.8 之后
新增非抽象方法
- 被
public default
修饰的非抽象方法 - 静态方法
注意
default
修饰符必须要加上,否则出错
static
修饰静态方法不可以不写
package com.impl;
public interface TestInterface {
public abstract void a();
// 非抽象方法
public default void b() {
System.out.println("TestInterface b()");
}
}
class Test1 implements TestInterface{
public void c() {
b(); // 可以使用接口里的b方法
TestInterface.super.b(); // 可以这样进行调用
}
@Override
public void a() {
System.out.println("aaa");
}
}
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 为什么要在接口加非抽象方法
如果接口中只能定义抽象方法,我要是修改接口中的内容,那么对所有实现类的影响太大了;现在在接口中加入非抽象方法,对实现类没有影响,想调用就去调用。
public interface It1 {
void a();
void b();
// 加一个抽象方法,所有的实现类都得实现一遍
public default void c() {
}
}
class Test01 implements It1 {
@Override
public void a() {
}
@Override
public void b() {
}
}
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
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
编辑 (opens new window)
上次更新: 2021/11/10, 23:27:25