接口

一、接口的概念

1. 接口：是一种标准、规范，接口的使用者和接口的实现者都
   必须遵循的约定。

2. 语法：（基于 jdk7.0 版本） 【重点】
   (1) 关键字： interface
   interface 接口名{}
   (2) 接口在编译之后会生独立 .class 文件
   (3) 接口不能创建对象，但是可以声明引用。
   接口名 变量名;
   (4) 接口中没有构造方法
   (5) 接口中属性都是公开、静态、常量(默认被 public static final 修饰)
   (6) 接口中方法都是公开、抽象方法(默认被 public abstract修饰)
   注意：接口从语法角度是一个特殊的抽象类，是对抽象类进一步的抽象。
   但是接口 从 Java分类：不是类。

   public class TestMyInter{
   	public static void main(String[] args){
   		MyInter mi ;
   		//MyInter.n = 20;
   		System.out.println(MyInter.n);
   		System.out.println(MyInter.m);
   		//MyInter.m = 50;
   	}
   }
   	// 抽象类
   	/*
   	抽象类不能单独new 对象，但是可以声明引用
   	抽象类：编译之后生成独立的 .class
   	*/
   abstract class MyClass{
   	int a = 3;  // 实例变量
   	static int b = 7; // 静态变量
   	ublic MyClass(){}
   	public void m1(){}
   	public abstract void m2();
   }
   // 接口:共语法角度，相当于 特殊的抽象类
   interface MyInter{
   	int m =0;  // 默认 被 static ,同是 被 final修饰
   	static int n = 7; // 静态变量,默认 被 final修饰
   	//public MyInter(){} // 接口中没有构造方法
   	public void t1();// 默认的被 public abstract 修饰
   	public abstract void t2();
   	void t3();// 被 public abstract 修饰
   }
   	```
   

3. 实现类 【开发应用重点】
   (1) 语法：
   class 类名 implements 接口名{}
   (2) 注意：
   a. 如果实现类不想定义为 抽象类，则必须覆盖接口中所有的抽象方法，同时给与实现；否则实现类必须定义为抽象类。
   b. 接口中方法默认的访问权限为 public ，所以实现类覆盖接口中的方法时访问修饰符必须也是 public 。因为 类中方法如果不写访问修饰符。默认的访问权限为 default。
   (3) 使用：接口类型的引用中可以存储 实现类的对象，多态的应用
   语法：接口名 引用 = new 实现类类名(实参);
   注意：如果以接口类型的引用调用方法，只能调用 接口中有的方法。
   (4) 案例：

   public class TestInter{
   	public static void main(String[] args){
   		// 接口类型的引用 --》 实现类的对象
   		MyInter mi = new MyClass();  // 多态
   		mi.m1();
   		mi.m2();
   		//mi.m3();
   	}
   }
   // 接口
   interface MyInter{
   	public void m1();// 默认 被 abstract
   	void m2(); //默认 public abstract 修饰
   }
   // 接口的实现类 （从语法角度：类 继承一个 特殊的 抽象类）
   class MyClass implements MyInter{
   	public void m1(){
   		System.out.println("m1方法的实现....");
   	}
   	public void m2(){
   		System.out.println("m2方法的实现....");
   	}
   	public void m3(){}
   }
   ``

4. Java中接口的继承性 【开发应用重点】
   (1) 接口与接口之间是多继承
   语法：interface 接口名 extends 父类接口1,父接口2{}
   (2) 类和接口是实现的关系：即一个类可以同时实现多个接口
   ① 语法： class 类名 implements 接口名1,接口名2{}
   ② 注意：如果实现类不想成为抽象类,必须覆盖所有接口中的所有方法
   (3) 一个类继承一个父类的同时可以实现多个接口：
   ① 语法：class 类名 extends 父类 implements 接口1,接口名2{}
   ② 注意：必须先定义继承，再定义实现

5. 接口多继承的影响【理解】
   (1) 让多态的应用更加的复杂和多样性。
   (2) 如果强制类型转换的双方有一方为接口类型，编译一定通过，运行有以下两种情况：
   ① 如果实际存储对象类型和要转换的类型相兼容，则运行通过；
   ② 如果实际存储对象类型和要转换的类型不兼容，则运行报错，错误信息为：java.lang.ClassCastException(类型转换异常)
   注意：评判是否兼容：实际存储的对象类型是否为要转换类型一种

public class Test6{
	public static void main(String[] args){
		 MyClass mc = new MyClass();
	       /*System.out.println(mc instanceof ClassA);
		System.out.println(mc instanceof IA);
		System.out.println(mc instanceof IB);
		System.out.println(mc instanceof IC);
		System.out.println(mc instanceof ID);*/
		/*IA ia = mc;
		ia.m1();
		ia.m2();
		//ia.m3();*/
		/*IB ib = mc;
		ib.m3();*/
		/*IC ic = mc;
		ic.m1();
		ic.m2();
		ic.m3();
		ic.m4();*/
		/*ID id = mc;
		id.m5();*/
		ClassA ca = mc;
		ca.m6();
	}
}
interface IA{
	void m1();
	void m2();
}
interface IB{
	void m3();
}
interface IC extends IA,IB{
	void m4();
}
interface ID{
	void m5();
}
// 类和接口的多实现
class MyClass extends ClassA implements IC,ID {
	public void m1(){
		System.out.println("m1()...");
	}
	public void m2(){
		System.out.println("m2()...");
	}
	public void m3(){
		System.out.println("m3()...");
	}
	public void m4(){
		System.out.println("m4()...");
	}
	public void m5(){
		System.out.println("m5()...");
	}
}
class ClassA{
	public void m6(){
		System.out.println("m6()...");
	}
}

6. 接口的应用场景
(1) 利用接口扩充子类的能力 【开发中应用】
a. 类之间是单继承，当子类通过继承关系，从父类继承的功能不满足子类的功能需求时，可以利用接口扩充子类的功能需求。
b. 通常将主要功能定义在父类中，相对次要功能定义接口中。
(2) 依赖倒转原则：当一个类和其他类建立联系时，尽可能和父类或是接口建立联系，避开直接与其子类或是实现类建立联系。【理解】
a. 降低代码之间的耦合度，从而实现弱耦合
b. 提高程序的可维护性。