接口

一、接口的基本概念

接口与抽象类相似，但是它与抽象类又有不同的地方。接口的基本语法：

1. 使用interface定义;
2. 接口中的方法全都是抽象方法（abstract），数据成员必须赋初始值且是常量不能修改；
3. 接口中的成员都是public权限；
4. 实现接口用implements关键字（implements是特殊的继承！）；
5. 一个类(Phone)可以实现（继承）多个(USB,WIFI)接口（“多继承机制”）；
6. 接口不能被实例化，接口必须由其子类覆盖了所有的抽象方法后，该子类才可以实例化，否则，该子类还是一个抽象类。
   在JAVA中接口是用于实现多继承的一种机制，也是java设计中最重要的一个环节，每一个由接口实现的类必须在内部复写接口中的抽象方法，且可自由地使用接口中的常量。

例：接口的使用

package cn.edu.nupt;
//定义一个名称为USB的接口
public interface USB {
//在接口里定义两个抽象函数
	public void read();
	public void write();
}
package cn.edu.nupt;
//定义一个名称为WIFI的接口
public interface WIFI {
//在接口里定义两个抽象函数
	public void open();
	public void close();
package cn.edu.nupt;
//Phone类实现USB接口和WIFI接口
public class Phone implements USB,WIFI{
//在类中复写USB接口中的抽象方法
	public void read(){
		System.out.println("Phone read");
	}
	public void write(){
		System.out.println("Phone write");
	}
//在类中复写WIFI接口中的抽象方法
	public void open() {
		System.out.println("WIFI open");
	}
	public void close() {
		System.out.println("WIFI close");
	}
}
package cn.edu.nupt;
public class Test {
	public static void main(String[] args) {
		// 在Phone类中创建对象，并向上转型为接口的引用对象
		USB p=new Phone();
		p.read();
		p.write();
		
		WIFI f=new Phone();
		f.open();
		f.close();
	}
}

运行结果：

7. 一个接口可以继承多个接口。
   例：一个接口继承多个接口。

package cn.edu.nupt.b;
//定义一个名称为A的接口
public interface A {
	int a=1;
	public void fun1();
}
package cn.edu.nupt.b;
//定义一个名称为B的接口
public interface B {
	int b=2;
	public void fun2();
}
package cn.edu.nupt.b;
//定义一个名称为C的接口,C同时继承了A和B两个接口
public interface C extends A,B{
	int c=3;
	public void fun3();
}
package cn.edu.nupt.b;
//My类实现接口C，而C又继承了接口A和B，这意味着My类要复写A,B,C这3个接口的抽象方法
public class My implements C {
	public void fun1() {
		System.out.println("a="+a);	
	}
	public void fun2() {
		System.out.println("b="+b);	
	}
	public void fun3() {
		System.out.println("c="+c);	
	}
}
package cn.edu.nupt.b;
public class Test {
	public static void main(String[] args) {
		//在My类中创建对象，并向上转型为接口A的引用对象
		A a=new My();
		a.fun1();
		//在My类中创建对象，并向上转型为接口B的引用对象
		B b=new My();
		b.fun2();
		//在My类中创建对象，并向上转型为接口C的引用对象
		C c=new My();
		c.fun3();
	}
}

运行结果：

二、 接口的应用

案例场景：

现在办公室有两台打印机，分别是惠普打印机和佳能打印机，试编写程序，调用这两个打印机，调用的程序只需写开机，关机，打印一串字符即可。

1. 使用继承的思想
   先定义所有打印机的方法，再让惠普打印机和佳能打印机分别继承打印机的方法。

package cn.eud.nupt.a;
//定义打印机的方法
public class Printer {
//定义打印机的开机方法
	void open(){
		System.out.println("open the printer!");
	}
//定义打印机的开机方法
	void close(){
		System.out.println("close the printer！");
	}
//定义打印机打印方法
	void print( String s){
		System.out.println("Print:"+s);	
	}
}
package cn.eud.nupt.a;
//HPPrinter继承了打印机的所有方法
public class HPPrinter extends Printer{

}
package cn.eud.nupt.a;
//CannonPrinter继承了打印机的所有方法
public class CannonPrinter extends Printer{
//CannonPrinter还有独自的clean方法和close方法
	void clean(){
		System.out.println("clean the CannonPrinter!");
	}
//CannonPrinter独自的close方法复写父类的close方法
	void close(){
		this.clean();
		super.close();
	}
}
package cn.eud.nupt.a;
public class Test {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		HPPrinter a=new HPPrinter();
		a.open();
		a.close();
		a.print("你好！");
		
		System.out.println("**************************");
		
		CannonPrinter b=new CannonPrinter();
		b.open();
		b.close();
		b.print("Hellow!");
	}
}

运行结果：

结果分析：
以上的程序确实解决了实际的问题，但是也存在较大的问题。在实际生活中，惠普打印机与佳能打印机的开机关机方法肯定不一样，也就说，它们的方法有很多的不同。而使用继承的思想，使得惠普打印机与佳能打印机的方法全都差不多，这就存在着较大的漏洞。

2. 使用接口的思想
   定义一个接口（接口中的方法都是抽象的），再分别定义惠普打印机与佳能打印机两个类，这两个类分别实现定义的接口。再在这两个类中使用复写的方式分别复写接口中的抽象类！

package cn.edu.nupt.b;
//定义打印机接口
public interface Printer {
//定义抽象方法
		void open();
		void close();
		void print( String s);		
}
package cn.edu.nupt.b;
public class HPPrinter implements Printer {
//定义惠普打印机的开机方法，复写接口中的抽象开机方法
	public void open(){
		System.out.println("open the HPPrinter!");
	}
//定义惠普打印机的关机方法，复写接口中的抽象关机方法
	public void close(){
		System.out.println("close the HPPrinter！");
	}
//定义惠普打印机的打印方法，复写接口中的抽象打印方法
	public void print( String s){
		System.out.println("HPPrinter:"+s);	
	}
}
package cn.edu.nupt.b;
public class CannonPrinter implements Printer{
	//定义佳能打印机的开机方法
		public void open(){
			System.out.println("open the CannonPrinter!");
		}
	//定义佳能打印机的关机方法
		public void close(){
			clean();
			System.out.println("close the CannonPrinter！");
		}
	//定义佳能打印机的打印方法
		public void print( String s){
			System.out.println("CannonPrinter:"+s);	
		}
		
    //CannonPrinter还有独自的clean方法
		void clean(){
			System.out.println("clean the CannonPrinter!");
		}
}
package cn.edu.nupt.b;
//根据用户的选择，生成相应的打印机对象
public class PrinterFactory {
	public static Printer getPrinter(int flag){
		Printer a=null;
		if(flag==0)
			a=new HPPrinter();
		else if(flag==1)
			a=new CannonPrinter();
		return a;		
	}
}
package cn.edu.nupt.b;
public class Test {
	public static void main(String[] args) {
		int flag=1;
		Printer a=PrinterFactory.getPrinter(flag);
		a.open();
		a.close();
		a.print("哈哈！");
	}
}

运行结果：

3. 接口和抽象类的区别