java接口

接口

接口和抽象类的区别

抽象类的本质还是类，只是可以写抽象方法并且不能被new对象。
接口是另外一种类型。

声明类的关键字是class，声明接口的关键字是interface

抽象类是用来被继承的，接口是用来被实现的。类只能被单继承，但是接口可以被多实现，继承的关键字extends，实现的关键字是implements

接口中的方法都是抽象方法
接口中可以不用写方法，但是如果写方法了必须是抽象方法，接口中的方法默认是public abstract修饰的，可以不用写修饰符，但是如果写了，必须是public abstract 修饰的

public interface Test2 {
	public abstract void speak();
	public void run();
	abstract void look();
	void swim();
}

以上都是符合要求的。
接口中的方法不能用static修饰符修饰，因为static修饰符修饰的方法不能被重写，而抽象方法是要被子类或者实现类去重写的。
接口中的变量都是静态常量
接口中可以不写任何属性，但是写了就是public static final修饰的静态常量，声明的时候就必须赋值，因为接口中不可以写静态代码块。public修饰是因为要保证实现类可以使用这个变量，static修饰是因为static修饰的变量属于接口，不用static修饰的属于对象，而接口不能new对象，final修饰是因为如果子类可以随意更改接口中定义的常量值，那么也没必要写在接口中了。

一个类可以实现多个接口

public class Student implements A,B,C,D{
			//Student需要实现接口A B C D中所有的抽象方法
			//否则Student类就要声明为抽象类,因为有抽象方法没实现
		}

声明的变量可以调用什么方法，具体要看声明变量的类型,必要时也可以通过强制转换实现

public class Test {
	public static void main(String[] args) {
		A a = new C();
		a.speak();
		B b = new C();
		b.run();
		((A)b).speak();
		((B)a).run();
	}
}
interface A{
	void speak();
}
interface B{
	void run();
}
class C implements A,B{

	@Override
	public void speak() {
		// TODO Auto-generated method stub
		System.out.println("speak");
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("run");
	}
	
}

输出结果
speak
run
speak
run

一个接口可以继承多个父接口，如果一个类实现了这个接口，就相当于实现了这个接口以及所有的父接口，所以需要实现所有的抽象方法，这个类的对象也同时属于这个接口的类型以及它所有父接口的类型。

public class Test {
	public static void main(String[] args) {
		A a = new D();
		System.out.println(a instanceof A);//true
		System.out.println(a instanceof B);//true
		System.out.println(a instanceof C);//true
		System.out.println(a instanceof D);//true
	}
}
interface A{
	void speak();
}
interface B{
	void run();
}
interface C extends A,B{
	
}
class D implements C{
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("run");
	}

	@Override
	public void speak() {
		// TODO Auto-generated method stub
		
	}
	
}

a变量无论是ABCD哪个类型，结果都是true。
注:System.out.println(o instanceof X);
如果o是一个接口类型声明的变量,那么只要X不是一个final修饰的类,该代码就能通过编译（因为一个引用所指向的对象，是有可能实现任何一个接口的）,至于其结果是不是true,就要看变量o指向的对象的实际类型,是不是X的子类或者实现类了。

public class Test {
	public static void main(String[] args) {
		E a = new D();
		System.out.println(a instanceof A);//true
		System.out.println(a instanceof B);//true
		System.out.println(a instanceof C);//true
		System.out.println(a instanceof D);//true
		System.out.println(a instanceof E);//true
	}
}
interface A{
	
}
interface B{
	
}
interface C extends A,B{
	
}
class D extends E implements C{
	
}
class E{
	
}

无论变量a是ABCDE哪个类型，结果都是true，这也解释了“只要X不是一个final修饰的类,该代码就能通过编译”这句话