第六章：接口

系列文章目录

---

---

前言

接口是更加抽象的类。

---

一、接口

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);//把相机接入到计算机
	}
}

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

//语法形式
interface 接口
{
	//属性
	//方法
}

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

接口本质
接口就是更加抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体【JDK7.0】
接口体现了程序设计的多态和高内聚低耦合的设计思想
【JDK8.0】后接口可以有静态方法，成员方法，也就是说接口中可以有方法的具体实现

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();
	}
}

接口使用细则part1
1）接口不能被实例化
2）接口中所有的方法是public方法，接口中抽象方法，可以不用abstract修饰
3）一个普通类实现接口，就必须将该接口的所有方法都实现
4）抽象类实现接口，可以不用实现接口的方法

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 {
}

接口使用细则part2
5）一个类可以同时实现多个接口
6）接口中的属性，只能是final的，而且是public static final 修饰符。比如：int a = 1；实际上是public static final int a = 1；(必须初始化)
7）接口中的属性的访问形式：接口名.属性名
8）接口不能继承其他类，但可以继承多个别的接口
9）接口的修饰符 只能是public和默认，这点和类的修饰符是一样的

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() {}
}

二、实现接口与继承类

实现接口和继承类的区别
当子类继承了父类，就自动的拥有父类的功能，解决代码的复用性和可维护性
如果子类需要扩展功能，可以通过实现接口的方式扩展，设计好各种规范（方法），让其它类去实现这些方法，即更加灵活
接口比继承更加灵活，继承是满足is - a的关系，而接口只需满足 like - a的关系
可以理解实现接口是对java单继承机制的一种补充，接口在一定程度上实现代码解耦，即接口规范性+动态绑定机制

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() + " 通过学习， 可以像鸟儿一样飞翔...");
	}
	
}

三、接口的多态特性

接口的多态性
多态参数：接口引用可以指向实现了接口的类的对象
多态数组：数组引用可以指向实现了接口的类的对象
多态传递：接口继承父接口可以被接口实现并实现接口的类的引用

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 {}

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("相机工作中...");
	}
}

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() {}
}

---

总结

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