第六章：接口

系列文章目录

---

---

前言

接口是更加抽象的类。

---

一、接口

usb插槽就是现实中的接口，厂家都遵守了统一的规定包括尺寸，排线等。这样的设计在java编程中也是大量存在的。

package com.hspedu.interface_;

public interface UsbInterface { //接口
	//规定接口的相关方法,老师规定的.即规范...
	public void start();
	public void stop();
} 

package com.hspedu.interface_;

public class Camera implements UsbInterface{//实现接口,就是把接口方法实现

	@Override
	public void start() {
		System.out.println("相机开始工作...");
	} 
	
	@Override
	public void stop() {
		System.out.println("相机停止工作....");
	}
}

package com.hspedu.interface_;

//Phone 类 实现 UsbInterface
//解读 1. 即 Phone 类需要实现 UsbInterface 接口 规定/声明的方法
public class Phone implements UsbInterface {

	@Override
	public void start() {
		System.out.println("手机开始工作...");
	} 
	
	@Override
	public void stop() {
		System.out.println("手机停止工作.....");
	}
}


package com.hspedu.interface_;

public class Interface01 {
	public static void main(String[] args) {
		//创建手机， 相机对象
		//Camera 实现了 UsbInterface
		Camera camera = new Camera();
		//Phone 实现了 UsbInterface
		Phone phone = new Phone();
		//创建计算机
		Computer computer = new Computer();
		computer.work(phone);//把手机接入到计算机
		System.out.println("===============");
		computer.work(camera);//把相机接入到计算机
	}
}
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

接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，在根据具体情况把这些方法写出来。

//语法形式
interface 接口
{
	//属性
	//方法
	//比如：public void eat();
}

class 类名 implements 接口
{
	//自己属性
	//自己方法
	//必须实现的接口的抽象方法
}

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

package com.hspedu.interface_;

public interface DBInterface { //项目经理
	public void connect();//连接方法
	public void close();//关闭连接
} 

package com.hspedu.interface_;

//A 程序
public class MysqlDB implements DBInterface {
	@Override
	public void connect() {
		System.out.println("连接 mysql");
	} 
	@Override
	public void close() {
		System.out.println("关闭 mysql");
	}
}
 

package com.hspedu.interface_;

//B 程序员连接 Oracle
public class OracleDB implements DBInterface{
	@Override
	public void connect() {
		System.out.println("连接 oracle");
	} 
	@Override
	public void close() {
		System.out.println("关闭 oracle");
	}
} 

package com.hspedu.interface_;

public class Interface03 {
	public static void main(String[] args) {
		MysqlDB mysqlDB = new MysqlDB();
		t(mysqlDB);
		OracleDB oracleDB = new OracleDB();
		t(oracleDB);
	} 
	public static void t(DBInterface db) {
		db.connect();
		db.close();
	}
}
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

package com.hspedu.interface_;

public class InterfaceDetail01 {
	public static void main(String[] args) {
		//new IA();
	}
} 

//1.接口不能被实例化
//2.接口中所有的方法是 public 方法, 接口中抽象方法， 可以不用 abstract 修饰
//3.一个普通类实现接口,就必须将该接口的所有方法都实现,可以使用 alt+enter 来解决
//4.抽象类去实现接口时， 可以不实现接口的抽象方法

interface IA {
	void say();//修饰符 public protected 默认 private
	void hi();
} 

class Cat implements IA{
	@Override
	public void say() {} 
	@Override
	public void hi() {}
} 

abstract class Tiger implements IA {
}
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

package com.hspedu.interface_;

public class InterfaceDetail02 {
	public static void main(String[] args) {
	//老韩证明 接口中的属性,是 public static final
	System.out.println(IB.n1);//说明 n1 就是 static
	//IB.n1 = 30; 说明 n1 是 final
	}
} 

interface IB {
	//接口中的属性,只能是 final 的， 而且是 public static final 修饰符
	int n1 = 10; //等价 public static final int n1 = 10;
	void hi();
} 

interface IC {
	void say();
}

//接口不能继承其它的类,但是可以继承多个别的接口
interface ID extends IB,IC {} 

//接口的修饰符 只能是 public 和默认， 这点和类的修饰符是一样的
interface IE{}

//一个类同时可以实现多个接口
class Pig implements IB,IC {
	@Override
	public void hi() {} 
	@Override
	public void say() {}
}
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

二、实现接口与继承类

package com.hspedu.interface_;

public class ExtendsVsInterface {
	public static void main(String[] args) {
		LittleMonkey wuKong = new LittleMonkey("悟空");
		wuKong.climbing();
		wuKong.swimming();
		wuKong.flying();
	}
} 

//猴子
class Monkey {
	private String name;
	public Monkey(String name) {
		this.name = name;
	} 
	public void climbing() {
		System.out.println(name + " 会爬树...");
	} 
	public String getName() {
		return name;
	}
} 

//接口
interface Fishable {
	void swimming();
} 
interface Birdable {
	void flying();
} 

//继承
//小结: 当子类继承了父类， 就自动的拥有父类的功能
// 如果子类需要扩展功能， 可以通过实现接口的方式扩展.
// 可以理解 实现接口 是 对 java 单继承机制的一种补充.
class LittleMonkey extends Monkey implements Fishable,Birdable {

	public LittleMonkey(String name) {
		super(name);
	} 
	
	@Override
	public void swimming() {
		System.out.println(getName() + " 通过学习， 可以像鱼儿一样游泳...");
	} 
	
	@Override
	public void flying() {
		System.out.println(getName() + " 通过学习， 可以像鸟儿一样飞翔...");
	}
	
}

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

三、接口的多态特性

package com.hspedu.interface_;

public class InterfacePolyParameter {
	public static void main(String[] args) {
	//接口的多态体现
	//接口类型的变量 if01 可以指向 实现了 IF 接口类的对象实例
	IF if01 = new Monster();
	if01 = new Car();
	//继承体现的多态
	//父类类型的变量 a 可以指向 继承 AAA 的子类的对象实例
	AAA a = new BBB();
	a = new CCC();
	}
}

interface IF {}
class Monster implements IF{}
class Car implements IF{}
class AAA {} 
class BBB extends AAA {}
class CCC extends AAA {}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

package com.hspedu.interface_;

public class InterfacePolyArr {
	public static void main(String[] args) {
		//多态数组 -> 接口类型数组
		Usb[] usbs = new Usb[2];
		usbs[0] = new Phone_();
		usbs[1] = new Camera_();
		/*
		给 Usb 数组中， 存放 Phone 和 相机对象， Phone 类还有一个特有的方法 call（） ，
		请遍历 Usb 数组， 如果是 Phone 对象， 除了调用 Usb 接口定义的方法外，
		还需要调用 Phone 特有方法 call
		*/
		for(int i = 0; i < usbs.length; i++) {
			usbs[i].work();//动态绑定..
			//和前面一样， 我们仍然需要进行类型的向下转型
			if(usbs[i] instanceof Phone_) {//判断他的运行类型是 Phone_
				((Phone_) usbs[i]).call();
			}
		}
	}
} 

interface Usb{
	void work();
} 

class Phone_ implements Usb {
	public void call() {
		System.out.println("手机可以打电话...");
	} 
	@Override
	public void work() {
		System.out.println("手机工作中...");
	}
} 

class Camera_ implements Usb {
	@Override
	public void work() {
		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

ackage com.hspedu.interface_;

/**
* 演示多态传递现象
*/
public class InterfacePolyPass {
	public static void main(String[] args) {
	//接口类型的变量可以指向， 实现了该接口的类的对象实例
	IG ig = new Teacher();
	//如果 IG 继承了 IH 接口， 而 Teacher 类实现了 IG 接口
	//那么， 实际上就相当于 Teacher 类也实现了 IH 接口.
	//这就是所谓的 接口多态传递现象.
	IH ih = new Teacher();
	}
} 
interface IH {
	void hi();
} 
interface IG extends IH{ }

class Teacher implements IG {
	@Override
	public void hi() {}
}
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

---

总结

接口的使用更多是对类继承的一种补充。