【Java笔记】接口（interface关键字）的使用

有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。

接口就是规范，契约，标准，规范，定义的是一组规则，体现了现实世界中 “如果你是...则必须能...” 的思想。继承是一个 “是不是” 的关系，而接口实现则是 “能不能” 的关系。

目录

接口的使用

JDK 7 及以前的接口

JDK 8 及以后的接口

创建接口匿名实现类的对象

---

接口的使用

1. 接口使用 interface 来定义

2. Java 中，接口和类是并列的两个结构

3. 接口中不能定义构造器，意味着接口不可以实例化

4. Java 开发中，接口通过让类去实现（implement）的方式来使用

        如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化

        如果实现类没有覆盖接口中的所有抽象方法，则此实现类仍为一个抽象类

5. Java 类可以实现多个接口，这弥补了 Java 单继承性的局限性

        格式：class A extends B implement C,D,E

6. 接口与接口之间可以继承，而且可以多继承

7. 接口的使用，体现了多态性

JDK 7 及以前的接口

只能定义全局常量和抽象方法

全局常量：public static final ，但是书写时，可以省略不写

抽象方法：public abstract

public class InterfaceTest {
public static void main(String[] args) {
	System.out.println(Flyable.MAX_SPEED);
	System.out.println(Flyable.MIN_SPEED);
	Plane plane = new Plane();
	plane.fly();
	plane.attack();
    }
}
interface Flyable{
	// 全局常量
	public static final int MAX_SPEED = 7900;
	int MIN_SPEED = 1; // 省略了 public static final
	public static void fly() {};
}
interface Attackable{
	public abstract void attack();
}
class Plane implements Flyable,Attackable{
	public void fly() {
		System.out.println("飞机飞");
	}
	@Override
	public void attack() {
		System.out.println("飞机攻击目标");
	}	
}

>>> 7900
    1
    飞机飞
    飞机攻击目标

JDK 8 及以后的接口

除了定义全局常量和抽象方法外，还可以定义静态方法、默认方法

1. 接口中定义的静态方法，只能通过接口调用

2. 通过实现类的对象，可以调用接口中的默认方法， 如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法

3. 类优先原则

如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的方法，那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法    

4. 接口冲突

如果实现类实现了多个接口，而这个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错

5. 如果子类、实现类重写了父类、接口中的方法，我们仍要调用父类、接口的默认方法，则使用

父类：super . 方法（）

接口：接口 . super . 方法（）

public class InterfaceTest {
public static void main(String[] args) {
	SubClass s = new SubClass();
	// 1. 接口中定义的静态方法，只能通过接口调用
	AA.method1();
	// 2. 通过实现类的对象，可以调用接口中的默认方法
	//    如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
	s.method2();
	// 3. 类优先原则
	//    如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的方法
	//    那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法    
	// 4. 接口冲突
	//    如果实现类实现了多个接口，而这个接口中定义了同名同参数的默认方法
	//    那么在实现类没有重写此方法的情况下他，报错
	s.method3();
	s.method();
	}
}
interface AA{
	public static void method1() { // 静态方法
		System.out.println("AA1");
	}
	public default void method2() { // 默认方法
		System.out.println("AA2");
	}
	default void method3() {
		System.out.println("AA3");
	}
}
class SuperClass {
	public void method2() {
		System.out.println("Super2");
	}
	public void method3() {
		System.out.println("Super3");
	}
}
class SubClass extends SuperClass implements AA{
	public void method3() {
		System.out.println("Sub3");
	}
	public void method2() {
		System.out.println("Sub2");
	}
	public void method() {
		// 如果子类、实现类重写了父类、接口中的方法，父类、接口中的默认方法该如何被调用呢？
		// 我们可以使用如下方法调用
		super.method3(); // 调用父类声明的方法
		AA.super.method3(); // 调用接口的默认方法
	}
}

>>> AA1
    Sub2
    Sub3
    Super3
    AA3

创建接口匿名实现类的对象

public class InterfaceTest {
public static void main(String[] args) {
	SubClass s = new SubClass();
//	1. 创建接口的非匿名实现类的非匿名对象
	Sub sub = new Sub();
	s.transferData(sub);
	System.out.println("***********");
//	2. 创建接口的非匿名实现类的匿名对象
	s.transferData(new Sub());
	System.out.println("***********");
//	3. 创建接口的匿名实现类的非匿名对象
	Sub s1 = new Sub() {
		public void method2() {
			System.out.println("s1 method2");
		}
	};
	System.out.println("***********");
//	4. 创建接口的匿名实现类的匿名对象
	s.transferData(new Sub() {
		public void method2() {
			System.out.println("Sub method2");
		}
	});
	}
}
interface AA{
	public static void method1() { // 静态方法
		System.out.println("AA1");
	}
	public default void method2() { // 默认方法
		System.out.println("AA2");
	}
	default void method3() {
		System.out.println("AA3");
	}
}
class SubClass{
	public void transferData(AA a) {
		a.method2();
	}
}
class Sub implements AA{
	
}

>>> AA2
    ***********
    AA2
    ***********
    ***********
    Sub method2