面对对象编程（高级）——接口

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

//语法
interface 接口名 {
	//属性
	//方法
}

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

小结：接口是更加抽象的抽象的类，抽象类里的方法可以有方法体
1.在Jdk7.0前，接口里的所有方法都没有方法体。接口体现了程序设计的多态和高内聚低耦合的设计思想
2.Jdk8.0后接口类可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现

深入讨论
对初学者讲，理解接口的概念不算太难，难的是不知道什么时候使用接口，下面举例几个应用场景：
（1）说现在要制造战斗机，武装直升机；专家只需把飞机需要的功能/规格定下来即可，然后让别的人具体实现即可。
（2）说现在有一个项目经理，管理三个程序员，功能开发一个软件，为了控制和管理软件，项目经理可以定义一些接口，然后有程序员具体实现。
实际要求：3个程序员，编写三个类，分别实现对Mysql, Oracle, DB2数据库的连接connect，close。

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

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

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

//main方法
	public static void main(String[] args) {
		MysqlDB mysqlDB = new MysqlDB();
		t(mysqlDB);
		OracleDB oracleDB = new Oracle();
		t(oracleDB);
	}

	public  static void t(DBInterface db) {
		db.connect();
		db.close();
	}

注意事项和使用细节
（1）接口不能被实例化
（2）接口中所有的方法是public方法，接口中抽象方法，可以不用abstract修饰
（3）一个普通类实现接口，就必须将该接口的所有方法都实现
（4）抽象类实现接口，可以不用实现接口的方法
（5）一个类同时可以实现多个接口
（6）接口中的属性，只能是final的，而且是public static final修饰符。比如：int a = 1; 实际上是public static final int a = 1; （必须初始化）
（7）接口中的属性的访问形式：接口名.属性名
（8）接口不能继承其他的类，但是可以继承多个别的接口
（9）接口的修饰符 只能是public 和默认，这点和类的修饰符是一样的。

接口 vs 继承类

小结：
当子类继承了父类，就自动地拥有父类的功能；如果子类需要扩展功能，可以通过实现接口的方式扩展；可以理解 实现接口是对Java单继承机制的一种补充。

A.接口和继承解决的问题不同：
继承的价值主要在于：解决代码的复用性和可维护性；
接口的价值主要在于：设计，设计好各种规范（方法），让其他类去实现这些方法，即更加的灵活。。

B.接口比继承更加灵活：
接口比继承更加灵活，继承是满足is-a的关系，而接口只需满足like-a的关系。

C.接口在一定程度上实现代码解耦【即 接口规范性 + 动态绑定】

接口的多态特性
（1）多态参数
在前面的Usb接口案例，UsbInterface usb，既可以接受手机对象，又可以接受相机对象，就体现了 接口多态 （接口引用可以指向实现了接口的类的对象）

interface IF {}
class Monster implements IF {}
class Car implements IF {}

class AAA {}
class BBB extends AAA {}
class CCC extends AAA {}

//main()方法

	//接口的多态体现
	//接口类型的变量if01可以指向实现了IF接口类的对象实例
	IF if01 = new Monster();
	if01 = new Car();
	
	//继承体现的多态
	//父类类型的变量a可以指向继承AAA的子类的对象实例
	AAA a = new BBB();
	a = new CCC();

（2）多态数组
演示一个案例：给Usb数组，存放Phone 和相机对象，Phone类还有一个特有的方法call()，请遍历Usb数组，如果是Phone对象，除了调用Usb接口定义的方法外，还需要调用Phone特有方法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("相机工作中...");
	}
}
//main()方法
	//多态数组 -> 接口类型数组
	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();
		}
	}

（3）接口存在多态传递现象

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

练习

interface A { 
	int x = 0;
}
class B {
	int x = 1;
}
class C extends B implements A {
	public void pX() {
		System.out.println("x");	//错误，原因不明确x
		//访问接口的x使用A.x; 访问父类的x使用super.x
		//System.out.println(A.x + " " + super.x);
	}
}
//main()方法
	new C().pX();