java中的interface

接口用于定义一个规范、标准。  

1.通过接口可以实现不同层次、不同体系对象的共同属性； 通过接口屏蔽底层差异。以数据库连接为例子：JDBC制定标准；数据厂商实现标准；用户使用标准。

2.接口也因为上述原因被用来保持架构的稳定性。

从设计思想上来看，接口是一种特殊的抽象类（但用不同的关键字表示，且两者有许多特性并不一致）。从定义上来看，interface关键字即可表示这是一个接口。 java中因为有了interface的加入，使得对类的功能扩展和对类的继承体系的优化，提供了好的途径。

基本注意点

1.与类相似，一个文件只能有一个public接口（理论上也可以没有），且与文件名相同。 在一个文件中不可同时定义一个public接口和一个public类。

2.一个接口中，所有方法自动为public（也可认为方法都是abstract），常量都是自动为public，static，final。  （而且不得用与之矛盾的关键字来进行修饰）

3.子类实现某个方法，该方法必须设为public，否则编译时报错。（除非子类以及该方法是abstract）

4.接口中不能含有static方法。

interface和abstract class的区别

1.一个子类可以同时implements多个interface，但只能extends一个abstract class。

2.interface内定义的方法都是public的，而abstract class内的则不一定。

3.interface内定义的成员对象都是static & final的，而abstract class不是 。（而且压根就不能是static或者final）

4.interface所有方法都不能有具体实现方法，只有一个申明，而abstract class内abstract的方法不能有实现，非abstract的方法可以有实现方法。

5.interface被implements时，所有方法都必须被实现，必须申明是public的，而abstract class被extends时只有abstract的方法才必须被实现，别的有默认实现的直接被继承过来。 （当然，如果子类也是abstract的，interface和abstract class都不一定要实现，不过这种情况很少出现）

6.abstract class可以有构造方法，interface中不能有构造方法。

7.interface中不能含有static方法，abstract class可以。（可以通过子类调用）

8.interface更多的是在系统架构设计方法中发挥作用，主要用于定义模块之间的通信契约。而abstract class在代码实现方面发挥作用，可以实现代码的重用。

一般有这样的原则：假如想创建的基础类没有任何方法定义（指具体实现方法）或者成员变量，那么无论如何都愿意使用接口，而不要选择抽象类。事实上，如果事先知道某种东西会成为基础类，那么第一个选择就是把它变成一个接口。只有在必须使用方法定义或者成员变量的时候，才应考虑采用抽象类。

接口的高级特性

如果一个类想要实现多个接口，我们将所有接口名置于 implements关键字的后面，并用逗号分隔它们。每个接口都会成为一个独立的类型，可对其进行上溯造型。

interface CanFight {
	void fight();
}
interface CanSwim {
	void swim();
}
interface CanFly {
	void fly();
}
class ActionCharacter {
	public void fight() {
		System.out.println("ActionCharacter fight");
	}
}
class Hero extends ActionCharacter implements CanFight, CanSwim, CanFly {
	public void swim() {
		System.out.println("Hero swim");
	}
	public void fly() {
		System.out.println("Hero fly");
	}
}
class Adventure {
	static void t(CanFight x) {
		x.fight();
	}
	static void u(CanSwim x) { 
		x.swim(); 
	}
	static void v(CanFly x) {
		x.fly(); 
	}
	static void w(ActionCharacter x) { 
		x.fight(); 
	}
	public static void main(String[] args) {
		Hero i = new Hero();
		t(i); // Treat it as a CanFight
		u(i); // Treat it as a CanSwim
		v(i); // Treat it as a CanFly
		w(i); // Treat it as an ActionCharacter
	}
}

通常，我们只能对单独一个类应用 extends（扩展）关键字。但由于接口可能由多个其他接口构成，所以在构建一个新接口时，extends可能引用多个基础接口。

interface Monster {
	void menace();
}
interface DangerousMonster extends Monster {
	void destroy();
}
interface Lethal {
	void kill();
}
interface Vampire extends DangerousMonster, Lethal {
	void drinkBlood();
}
class DragonZilla implements DangerousMonster {
	public void menace() {}
	public void destroy() {}
}
class VampireImpl implements Vampire {
	public void destroy() {}
	public void menace() {}
	public void kill() {}
	public void drinkBlood() {}
}

接口还要一个功能：常数分组。（其实最好不一定要用接口，重点是static&&final）

用接口表示常数：

public interface Months {
int
JANUARY = 1, FEBRUARY = 2, MARCH = 3,
APRIL = 4, MAY = 5, JUNE = 6, JULY = 7,
AUGUST = 8, SEPTEMBER = 9, OCTOBER = 10,
NOVEMBER = 11, DECEMBER = 12;
}

更优方法（可防止子类覆盖）：

public final class Month2 {
	private String name;
	private Month2(String nm) { 
		name = nm; 
	}
	public String toString() { 
		return name; 
	}
	public final static Month2
		JAN = new Month2("January"),
		FEB = new Month2("February"),
		MAR = new Month2("March"),
		APR = new Month2("April"),
		MAY = new Month2("May"),
		JUN = new Month2("June"),
		JUL = new Month2("July"),
		AUG = new Month2("August"),
		SEP = new Month2("September"),
		OCT = new Month2("October"),
		NOV = new Month2("November"),
		DEC = new Month2("December");
	public final static Month2[] month = {
		JAN, JAN, FEB, MAR, APR, MAY, JUN,
		JUL, AUG, SEP, OCT, NOV, DEC
	};
	public static void main(String[] args) {
		Month2 m = Month2.JAN;
		System.out.println(m);
		m = Month2.month[12];
		System.out.println(m);
		System.out.println(m == Month2.DEC);
		System.out.println(m.equals(Month2.DEC));
	}
}