接口概念

如果一个类之中只是由抽象方法和全局常量所组成的，那么在这种情况下不会将其定义为一个抽象类，而只会将其定义为接口，所以所谓的接口严格来讲就属于一个特殊的类，而且这个类里面只有抽象方法与全局常量。

interface A { 					// 定义接口
	public static final String MSG = "YOOTK"; // 全局常量
	public abstract void print(); 		// 抽象方法
}

接口使用规则

             Ø  接口必须要有子类，但是此时一个子类可以使用implements关键字实现多个接口，避免了单继承局限；

             Ø  接口的子类（如果不是抽象类），必须要覆写接口中的全部抽象方法；

             Ø  接口的对象可以利用子类对象的向上转型进行实例化操作。

实现接口

interface A { 	// 定义接口
	public static final String MSG = "ww"; 	// 全局常量
	public abstract void print(); // 抽象方法
}
interface B {		// 定义接口
	public abstract void get();// 抽象方法
}
class X implements A, B { 			// X类实现了A和B两个接口
	public void print() {	// 覆写A接口的抽象方法
		System.out.println("A接口的抽象方法！");
	}
	public void get() {	// 覆写B接口的抽象方法
		System.out.println("B接口的抽象方法！");	}
}
public class TestDemo {
	public static void main(String args[]) {	// 此时X类是A和B两个接口的子类，所以此类对象可以同时实现两个接口的向上转型
		X x = new X(); // 实例化子类对象
		A a = x; // 向上转型
		B b = x; // 向上转型
		a.print();// 调用被覆写过的方法
		b.get();// 调用被覆写过的方法
		System.out.println(A.MSG);// 直接访问全局常量
	}
}

程序执行结果：

A接口的抽象方法！（“a.print()”语句执行结果）

B接口的抽象方法！（“b.get()”语句执行结果）

ww（“A.MSG”语句执行结果）

子类同时继承抽象类和实现接口

interface A { 			// 定义接口
	public abstract void print(); // 抽象方法
}
interface B {		// 定义接口
	public abstract void get();	// 定义抽象方法
}
abstract class C {	// 定义抽象类
	public abstract void change();	// 定义抽象方法
}
class X extends C implements A, B { 	// X类继承了抽象类C，实现了A和B两个接口
	public void print() {		// 覆写接口A中的方法
		System.out.println("A接口的抽象方法！");
	}
	public void get() {	// 覆写接口B中的方法
		System.out.println("B接口的抽象方法！");
	}
	public void change() {	// 覆写抽象类C的方法
		System.out.println("C类的抽象方法！");
	}
}

抽象类只能继承一个抽象类，但是接口可以继承几个接口，但是接口不能继承抽象类

接口的多继承

interface A {				// 定义父接口
	public void funA();
}
interface B {				// 定义父接口
	public void funB();
}
interface C extends A, B {	// 利用extends，实现接口多继承
	public void funC();
}
class X implements C {		// 实现C接口子类要覆写全部抽象方法
	public void funA() {}		// A接口定义的方法
	public void funB() {}		// B接口定义的方法
	public void funC() {}		// C接口定义的方法
}

从继承关系上将抽象类的限制比接口限制较多：

1.  一个抽象类只能继承一个抽象类的父类而接口没有这个限制

2.  一个子类只能继承一个抽象类，却可以实现多个接口。

在接口里定义抽象类

interface A {
	public void funA();
	abstract class B {		// 定义接口中的抽象类
		public abstract void funB();
	}
}
class X implements A { 		// X实现了A接口
	public void funA() {
		System.out.println("Hello World !");
	}
	class Y extends B { 	// 内部抽象类的子类，可以选择性继承
		public void funB() {}
	}
}

在一个接口内部如果使用了static去定义一个内部接口表示是一个外部接口

interface A {
	public void funA();
	static interface B { 	// 外部接口
		public void funB();
	}
}
class X implements A.B { 	// X实现了A接口
	public void funB() {}
}