JavaSE 接口

一、接口的概念
1、接口：是一种标准，规范，接口的使用者和接口的实现者都必须遵循的规定。
2、语法：

关键字：Interface
Interface 接口名{}

• 接口在编译后会独立生成 .class 文件；

• 接口不能创建对象，但可以声明引用；
  接口名.变量名

• 接口中没有构造方法；

• 接口中属性都是公开，静态，常量（默认被public，static，final修饰）

• 接口中的方法都是公开的，抽象的（默认被public，abstract修饰）

注意：接口从语法角度是一个特殊的抽象类，是对抽象类进一步的抽象。
但是接口从java分类：不是类（不用class修饰）

class Test2{
	public static void main(String[] args){
		MyClass mc;
		MyClass.b = 10;
		System.out.println(MyClass.b);//10
		MyInter mi ;
		//MyInter.n = 20;//无法为最终变量 n 指定值
		System.out.println(MyInter.n);//10
		//yInter.n = 10;//无法为最终变量 n 指定值
		System.out.println(MyInter.m);
	}
}
//抽象类
/*
	抽象类不能单独new对象，但是可以声明引用
	抽象类：编译之后生成独立的 .class
*/
abstract class MyClass{
	int a = 3;//实例变量
	static int b = 7;
	public MyClass(){}
	public void m1(){}
	public abstract void m2(){}
}
//接口：共语法角度，相当于 特殊的 抽象类
interface  MyInter{
	int m = 6;
	static int n = 7;
	//public MyInter(){}//接口中没有构造方法
	public void t1();//接口中的方法都是公开的，抽象的
	public abstract void t2();
	void t3();
}

3、实现接口的类 （重点）

• 语法：
  class 类名 implements 接口名{}

• 注意：
  a.如果实现类不想定义为抽象类，则必须覆盖接口中所有的抽象方法，同时将他实现，否则实现类必须定义为抽象类。（类似于abstract方法的实现）
  b.接口中方法默认的访问权限为public。因为类中方法如果不写访问修饰符，默认的访问权限为default。

• 使用：接口类型的引用中可以实现类的对象，多态的应用

• 语法：接口名 引用 = new 实现类类名(实参);

• 注意：如果以接口类型的引用调用方法，只能调用接口中有的方法。

• 案例：

class Test3{
	public static void main(String[] args){
		MyInter mi = new MyClass();  //多态
		mi.m1();
		mi.m2();
		//mi.m3();//找不到符号,mi 是MyInter类，需要强转
		
	}
}
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(){
		System.out.println("m3()实现方法...");
	}
}

4、Java中接口的继承性 （重点）

• 接口与接口之间是多继承
  语法：interface 接口名 extends 父类接口1,父类接口2{}

• 类和接口是实现的关系：即一个类可以同时实现多个接口
  语法：class 类名 implements 接口名去,接口名2{}
  注意：如果实现类不想成为抽象类,必须覆盖所有接口中的所有方法

• 一个类继承一个父类的同时可以实现多个接口：
  语法：class 类名 extends 父类 implements 接口1,接口2{}
  注意：必须先定义继承，再定义实现

5、接口多继承的影响（理解）

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

class TestInterface{
	public static void main(String[] args){
		MyClass mc = new MyClass();
		mc.m1();
		IA ia = mc;
		ia.m1();//m1的实现...
		ia.m2();//m2的实现...
		
		ClassA ca = new MyClass();
		IB ib1 = (IB)ca;
		ib1.m3();//m3的实现...
		
		/*ClassA ca2 = new ClassA();
		  IB ib2 = (IB)ca2;
		  编译通过，运行时java.lang.ClassCastException类转换异常
		*/
	}
}
interface IA{
	void m1();
	void m2();
}
interface IB{
	void m3();
}
interface IC extends IA,IB{
	void m1();
	void m2();
	void m3();
	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、接口的应用场景

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

public class TestComputer{
	public static void main(String[] args){
		// 创建电脑对象
		Computer c = new Computer();
		// 创建鼠标对象
		Mouse m = new Mouse();
		c.useDevice(m);//咔嚓...
		
		Keyboard k = new Keyboard(); // 实现类对象对象
		c.useDevice(k);//噼里啪啦...
		
		Fan f = new Fan();
		c.useDevice(f);//呼呼...
	}
}
// A类   --》使用者
class Computer{
	// 鼠标
	public void useDevice(USB usb){//USB usb = f;  --->体现的多态
		usb.service();
	}
}
// 对电子设备 和 电脑做一个标准和规范(接口)
interface USB{
	void service();
}
// 实现类
// B类
class Mouse implements USB{
	public void service(){
		System.out.println("咔嚓...");
	}
}
// C类
class Keyboard implements USB{
	public void service(){
		System.out.println("噼里啪啦...");
	}
}
// D类
class Fan implements USB{
	public void service(){
		System.out.println("呼呼...");
	}
}

7、JDK高版本对接口语法升级（了解）

• JDK8.0版本接口的升级内容,可以定义默认方法 和 静态方法
  –》可以定义默认方法
  a.语法：default 返回值类型 方法名(形参列表){}
  b.注意：
  1，接口中默认方法中的 default不再是访问修饰符，代表此方法可以写方法的实现部分
  2， 接口中 默认方法 访问权限为 public
  –》可以定义静态方法：
  a.语法：public static 返回值类型 方法名(形参列表){}
  b.注意：接口中静态方法默认访问权限也是 public，可以省略
  c.使用：接口名.静态方法名(实参);

• JDK9.0版本接口中升级：可以定义 私有方法
  语法：private 返回值类型 方法名 (形参列表){}

8、接口的分类

• 常量接口：接口中只有公开静态常量,没有定义任何方法 --》应用不广泛
• 标记接口：空接口，接口中没有定义任何的常量，也没有定义任何的方法，
  例如：IO中对象序列化
• 普通接口：具有至少定义一个抽象方法。–》开发广泛应用
• 函数式接口：是一种特殊的普通接口，接口中只有一个抽象方法，对静态方法和默认方法没有要求。

9、接口回调：

• 将接口对应的实现类对象作为实际参数赋值给接口类型的引用，当接口类型的引用调用方法时，实际运行的是对应实现类中的方法（覆盖），实现类作为实际参数传递给引用类型。目的是让接口的使用者完成对应的功能，这样现象称为接口回调。
• 使用场景：通常接口制定好之后，接口的使用者先被定义，根据需求的不同，再定义接口的实现者（先有接口的使用者，再有接口的实现者），开发时一旦出现接口回调现象，作为开发人员，通常关注的根据需求定义接口的实现类，无需关注接口的使用者。

抽象类与接口的区别：