使用接口的核心原因：为了向上转型为多个基类型，以及由此带来的灵活。

package thinkingInJava.interfaces;

//: interfaces/Adventure.java
//Multiple interfaces.
/*
 * 本例子展示就是使用接口的核心原因：为了向上转型为多个基类型，以及由此带来的灵活。
 * */
interface CanFight {
	void fight();
}

interface CanSwim {
	void swim();

	void fight();//故意放进一个和接口CanFight相同的方法
}

interface CanFly {
	void fly();
}

class ActionCharacter {
	public void fight() {//故意写一个和接口CanFight，CanSwim相同的方法
		System.out.println("----我可以战斗！");
	}
}

class Hero extends ActionCharacter implements CanFight, CanSwim, CanFly {
	/*
	 * 在父类、接口中那些相同的方法将具有相同的特征签名
	 * 也就是说它们方法的交集将指向同一个代表(这个是自己的称呼哈！O(∩_∩)O哈哈~)
	 */
	public void swim() {
		System.out.println("----我可以游泳！");
	}

	public void fly() {
		System.out.println("----我可以飞翔！");
	}
}

public class Adventure {

	public static void t(CanFight x) {
		System.out.println("来自CanFight：");
		x.fight();
	}

	public static void u(CanSwim x) {
		System.out.println("来自CanSwim：");
		x.swim();
		x.fight();
	}

	public static void v(CanFly x) {
		System.out.println("来自CanFly：");
		x.fly();
	}

	public static void w(ActionCharacter x) {
		System.out.println("来自ActionCharacter：");
		x.fight();
	}

	public static void main(String[] args) {
		/*
		 * t,u,v,w方法中传递的参数可以向上某个接口或者类
		 */
		Hero h = new Hero();
		t(h); // Treat it as a CanFight,向上某个接口CanFight
		u(h); // Treat it as a CanSwim,向上某个接口CanSwim
		v(h); // Treat it as a CanFly,向上某个接口CanFly
		w(h); // Treat it as an ActionCharacter,向上某个类ActionCharacter
	}
} // /:~


运行结果：

来自CanFight：
----我可以战斗！
来自CanSwim：
----我可以游泳！
----我可以战斗！
来自CanFly：
----我可以飞翔！
来自ActionCharacter：
----我可以战斗！

[color=red]对上述代码进行一下优化[/color]

经验来源：在ＪＤＫ的ＡＰＩ文档中我们会经常看见命名的规范和方法的重载，裁图示例！

[color=red]Arrays.fill[/color]
[img]http://dl.iteye.com/upload/picture/pic/77077/be1d761c-c6f0-3eca-b311-b9455b0ad0f5.jpg[/img]
[color=red]Arrays.binarySearch[/color]
[img]http://dl.iteye.com/upload/picture/pic/77075/f74ff6ba-700f-3cad-933b-50c22d8e0636.jpg[/img]

package tij.interfaces.test;


/*
 * 参考：package thinkingInJava.interfaces.Adventure.java;
 * 
 * 本例子展示就是使用接口的核心原因：为了向上转型为多个基类型，以及由此带来的灵活。
 * */
interface CanFight {
	void fight();
}

interface CanSwim {
	void swim();

	void fight();// 故意放进一个和接口CanFight相同的方法
}

interface CanFly {
	void fly();
}

class ActionCharacter {
	public void fight() {// 故意写一个和接口CanFight，CanSwim相同的方法
		System.out.println("----我可以战斗！");
	}
}

class Hero extends ActionCharacter implements CanFight, CanSwim, CanFly {
	/*
	 * 在父类、接口中那些相同的方法将具有相同的特征签名 也就是说它们方法的交集将指向同一个代表(这个是自己的称呼哈！O(∩_∩)O哈哈~)
	 */
	public void swim() {
		System.out.println("----我可以游泳！");
	}

	public void fly() {
		System.out.println("----我可以飞翔！");
	}
}

public class Adventure {
	/*
	 * 在这里重载了方法getPath：传递的参数不同，方便统一个调用名称
	 */

	public static void getPath(CanFight x) {
		System.out.println("来自CanFight：");
		x.fight();
	}

	public static void getPath(CanSwim x) {
		System.out.println("来自CanSwim：");
		x.swim();
		x.fight();
	}

	public static void getPath(CanFly x) {
		System.out.println("来自CanFly：");
		x.fly();
	}

	public static void getPath(ActionCharacter x) {
		System.out.println("来自ActionCharacter：");
		x.fight();
	}

	public static void main(String[] args) {
		/*
		 * 我们只需使用Hero类的上级来指向对象
		 * 这种方法也是非常实用的方式
		 */
		CanFight cf = new Hero();
		getPath(cf);

		CanSwim cs = new Hero();
		getPath(cs);

		CanFly cfly = new Hero();
		getPath(cfly);

		ActionCharacter ac = new Hero();
		getPath(ac);
	}
}

输出的结果和刚才一样：

来自CanFight：
----我可以战斗！
来自CanSwim：
----我可以游泳！
----我可以战斗！
来自CanFly：
----我可以飞翔！
来自ActionCharacter：
----我可以战斗！


.