Java 接口

接口

1.接口使用interface来定义

在java中，接口和类是并列的两个结构

如何定义接口，定义接口的成员

JDK7以前：只能定义全局常量和抽象方法

• 全局常量： pubilc static final
• 抽象方法：public abstract

JDK8以后：除了定义全局常量和抽象方法，还可以定义静态方法，默认方法（略）

接口中不能定义构造器，意味着借口不可以实例化

在Java开发中，接口通过让类去实现（implements）
如果实现类覆盖了接口中所有的方法，则此实现类就可以实例化，否则此实现类仍为一个抽象类

接口如何定义，如何使用如下

package Interface;

public class InterfaceTest {
	public static void main(String[] args) {
		System.out.println(Flyable.MAX_SPEED);
		plane p = new plane();
		p.fly();
	}
}

interface Flyable{
	// 全局常量
	public static final int MAX_SPEED = 7900; // 第一宇宙速度
	int MIN_SPEED = 1;    // public static final 书写时可以省略，但他也是全局常量

	// 抽象方法
	public abstract void fly();


	// 省略了 public abstract
	void stop();
}

class plane implements Flyable{

	@Override
	public void fly() {
		System.out.println("飞机通过引擎起飞");
	
	}

	@Override
	public void stop() {
		System.out.println("驾驶员减速停止");
	
	}

}
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

java类可以实现多接口，弥补了java单继承性的局限性

格式：

	class AA extends BB implements CC,DD,EE
1

例子如下

package Interface;

public class InterfaceTest {
	public static void main(String[] args) {
		System.out.println(Flyable.MAX_SPEED);
		plane p = new plane();
		p.fly();
	}
}

interface Flyable{
	// 全局常量
	public static final int MAX_SPEED = 7900; // 第一宇宙速度
	int MIN_SPEED = 1;    // public static final 书写时可以省略，但他也是全局常量

	// 抽象方法
	public abstract void fly();


	// 省略了 public abstract
	void stop();
}

interface Attackable{

	void attack();
}

class Bullet extends Object implements Flyable,Attackable{

	@Override
	public void attack() {
		System.out.println("子弹攻击");
	
	}

	@Override
	public void fly() {
		System.out.println("子弹飞");
	
	}

	@Override
	public void stop() {
		System.out.println("子弹停");
	
	}

}
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

接口与接口之间可以继承，而且可以多继承

interface AA{
	void method1();
}

interface BB{
	void method2();
}

interface CC extends AA,BB{

}
1
2
3
4
5
6
7
8
9
10
11

接口具体的使用能够体现多态性

接口可以看做是一个规范

以不变应万变，不变就是规范

接口同样也可以匿名实现

package Interface;

public class USBTest {
	public static void main(String[] args) {
		Computer com = new Computer();
	
		// 1.创建接口的非匿名对象
		Flash falsh = new Flash();
		com.transferData(falsh); // 接口的多态性
	
		// 2.创建接口的非匿名实现类的匿名对象
		com.transferData(new Printer());
	
		// 3.创建了匿名实现类的非匿名对象
		USB phone = new USB(){

			@Override
			public void start() {
				System.out.println("匿名实现类开始");
			
			}

			@Override
			public void stop() {
				System.out.println("匿名实现类结束");
			
			}
		
		};
		com.transferData(phone);
	
		// 4.创建了接口的匿名实现类的匿名对象
		com.transferData(new USB(){
			@Override
			public void start() {
				System.out.println("匿名实现类开始");
			
			}

			@Override
			public void stop() {
				System.out.println("匿名实现类结束");
			
			}
		});
	}
}


interface USB{
	// 定义了长宽高 ，最大最小传播速度等
	void start();

	void stop();
}

class Computer{
	public void transferData(USB usb){
		usb.start();
		System.out.println("具体的传输细节");
	
		usb.stop();
	}
}

class Flash implements USB{

	@Override
	public void start() {
		System.out.println("U盘开启工作");
	
	}

	@Override
	public void stop() {
		System.out.println("U盘结束工作");
	
	}

}

class Printer implements USB{

	@Override
	public void start() {
		System.out.println("打印机开始工作");
	
	}

	@Override
	public void stop() {
		System.out.println("打印机结束工作");
	
	}

}
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

简单的代理模式

package Interface;

public class NetworkTest {
	public static void main(String[] args) {
		Server server = new Server();
		ProxyServer proxyServer = new ProxyServer(server);
		proxyServer.browse();
	}

}

interface Nerwork{
	public void browse();
}


// 被代理类
class Server implements Nerwork{

	@Override
	public void browse() {
		System.out.println("真实的服务器访问网络");
	
	}

}

// 代理类
class ProxyServer implements Nerwork{

	private Nerwork work;
	
	public ProxyServer(Nerwork work){
		this.work = work;
	}

	public void check(){
		System.out.println("联网之前的检查工作");
	}
	@Override

	public void browse() {
		check();
		work.browse();
	}

}
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

java8中接口的新特性

还可以定义静态方法和默认方法

知识点一： 接口中定义的静态方法，只能接口来调。

知识点二：通过实现类的对象，可以调用接口中的默认方法，如果实现类重写了接口中的默认方法，仍然调用的是重写的方法

知识点三：如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法，那么子类在没有重写此方法的情况下，默认调用父类中的方法---->类优先原则

知识点四：如果实现类实现了多个接口，而多个接口实现了同名同参数的方法，那么在此类没有重新的情况下，会报错------>接口冲突

如果子类中重写了，但想调用接口的被重写的方法，如下

CompareA(接口名).super.方法名
1

一个例子如下

CompareA 文件

package Interface;

public interface CompareA {

	public static void method1(){
		System.out.println("CompareA.北京");
	}

	public default void method2(){
		System.out.println("CompareA.上海");
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13

SubClassTest 文件

package Interface;

public class SubClassTest {
	public static void main(String[] args) {
		SubClass s = new SubClass();
	
		CompareA.method1();//接口中定义的静态方法，只能接口来调
		s.method2(); //通过实现类的对象，可以调用接口中的默认方法
	}
}

class SubClass implements CompareA{
	public void method2(){
		System.out.println("重写method2");
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17