Think in Java - Chatpter 7 polymorphism 多态性

多态性：

• 是什么
• 怎么做

优点：

• 代码组织以及可读性均能获得改善
• 创建“易于扩展”的程序

Polymorphism - 动态绑定、推迟绑定或者运行期绑定

 

能够不顾衍生类，只让自己的代码与基础类打交道，那么省下的工作量将是难以估计的。

 

可在运行期间判断对象的类型，并分别调用适当的方法；

也就是说，编译器此时已然不知道对象的类型，但方法调用机制能自己去调查，找到正确的方法主体。

Java中绑定的所有方法都采用后期绑定技术，除非一个方法已被声明成final

final的使用：

• 防止其他人覆盖这个方法
• 有效“关闭”动态绑定，或者告诉编译器不需要进行动态绑定 - 编译器就可为final方法调用生成效率更高的代码

在一个设计良好的OOP程序中，而且只与基础类接口通信。

我们说这样的程序具有“扩展性”，因为可以从通用的基础类继承新的数据类型，从而新添一些功能。如果是为了适应新类的要求，那么对基础类接口进行操纵的方法根本不需要改变。

将发生改变的东西同没有发生改变的东西区分开

 

// accidentally changing the interface
class NoteX{
	public static final int 
		MIDDLE_C = 0, C_SHARP=1, C_FLAT=2;
}

class InstrumentX{
	public void play(int Notex){
		System.out.println("InstrumentX.play()");
	}
}

class WindX extends InstrumentX{
	// OOPS! Changes the method interface: 
	public void play(NoteX n){
		System.out.println("WindX.play(NoteX n)");
	}
}

public class WindError {
	public static void tune(InstrumentX i){
		// ...
		i.play(NoteX.MIDDLE_C);
	}
	public static void main(String[] args) {
		WindX flute = new WindX();
		tune(flute); //Not the desired behavior!
	}
}
/**
 * “过载”是指同一样东西在不同的地方具有多种含义；
 * “覆盖”是指它随时随地都只有一种含义，只是原先的含义完全被后来的含义取代了。
 * 在tune 中，“InstrumentX i”会发出play()消息，同时将某个 NoteX 成员作为自变量使用（MIDDLE_C）。
 * 由于NoteX 包含了int 定义，过载的play()方法的int 版本会得到调用。同时由于它尚未被“覆盖”，所以会使用基础类版本。 
 */

 

 抽象类：

Java 专门提供了一种机制，名为“抽象方法”。它属于一种不完整的方法，只含有一个声
明，没有方法主体。

包含了抽象方法的一个类叫作“抽象类”。如果一个类里包含了一个或多个抽象方法，类就必须指定成

abstract（抽象）。否则，编译器会向我们报告一条出错消息。

编译器可保证抽象类的“纯洁性”，我们不必担心会误用它。

如果从一个抽象类继承，而且想生成新类型的一个对象，就必须为基础类中的所有抽象方法提供方法定义。如果不这样做（完全可以选择不做），则衍生类也会是抽象的，而且编译器会强迫我们用abstract 关键字标志那个类的“抽象”本质。

 

接口：

“interface”（接口）关键字使抽象的概念更深入了一层。

我们可将其想象为一个“纯”抽象类。它允许创建者规定一个类的基本形式：方法名、自变量列表以及返回型，但不规定方法主体。

接口也包含了基本数据类型的数据成员，但它们都默认为static 和final。

注意接口中的每个方法都严格地是一个声明，它是编译器唯一允许的。

 

接口只是比抽象类“更纯”的一种形式；

但它用途并不止于此，由于接口根本没有具体的实施细节 - 也就是说，没有与存储空间与“接口”关联在一起 - 所以没有任何办法可以防止多个接口合并到一起。

 

/**
 * 接口的规则是：我们可以从它继承（稍后就会看到），但这样得到的将是另一个接口。
 * 如果想创建新类型的一个对象，它就必须是已提供所有定义的一个类。尽管Hero 没有为 fight()明确地提供
 * 一个定义，但定义是随同ActionCharacter 来的，所以这个定义会自动提供，我们可以创建Hero 的对象。
 * 
 * ActionCharacter.fight()
 * ActionCharacter.fight()
 */
// Multiple interfaces
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(){}
	public void fly(){}
}


public 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 
	}
}

 

接口可以：能上溯造型至多个基础类。

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

 

由于置入一个接口的所有字段都自动具有static 和final 属性，所以接口是对常数值进行分组的一个好工具：

// Using interfaces to create groups of constants 
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; 
} 

 

// Returning a handle to an inner class
abstract class Contents{
	abstract public int value();
}

interface Destination{
	String readLabel();
}

public class Parcel3 {
	private class PContents extends Contents{
		private int i = 11;
		public int value(){
			return i;
		}
	}
	protected class PDestination implements Destination{
		private String label;
		private PDestination(String whereTo){
			label =  whereTo;
		}
		public String readLabel(){
			return label;
		}
	}
	
	public Destination dest(String s){
		return new PDestination(s);
	}
	
	public Contents cont(){
		return new PContents();
	}
}

class Test{
	public static void main(String[] args){
		Parcel3 p = new Parcel3();
		Contents c = p.cont();
		Destination d = p.dest("Su Zhou");
		//Illegal -- can't access private class:
		//! Parcel3.PContents c = p.new PContents();
	}
}

 

package chapter07.innerscopes;

interface Destination {
	String readLabel();
}

package chapter07.innerscopes;

interface Contents {
	int value();
}

package chapter07.innerscopes;

public class Wrapping {
	private int i;
	public Wrapping(int x){
		i = x;
	}
	public int value(){
		return i;
	}
}

package chapter07.innerscopes;

public class Parcel4 {
	public Destination dest(String s){
		class PDestination implements Destination{
			private String label;
			private PDestination(String whereTo){
				label = whereTo;
			}
			public String readLabel(){
				return label;
			}
		}
		return new PDestination(s);
	}
	
	public static void main(String[] args) {
		Parcel4 p = new Parcel4();
		Destination d = p.dest("Su Zhou");
	}

}

package chapter07.innerscopes;

public class Parcel6 {
	public Contents cont(){
		// 创建从Contents 衍生出来的匿名类的一个对象
		// 由new表达式返回的句柄会自动上溯造型成一个Contents句柄。
		return new Contents(){
			private int i = 11;
			public int value(){
				return i;
			}
		}; // Semicolon required in this case
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}

package chapter07.innerscopes;

// 若试图定义一个匿名内部类，并想使用在匿名内部类外部定义的一个对象，则编译器要求外部对象为final属性。
public class Parcel8 {
	// Argument must be final to use inside anonymous inner class
	public Destination dest(final String dest){
		return new Destination() {
			private String label = dest;
			@Override
			public String readLabel() {
				return label;
			}
		};
	}

	public static void main(String[] args) {
		Parcel8 p = new Parcel8(); 
	    Destination d = p.dest("Su Zhou"); 
	}
}

// 必须利用外部类的一个对象生成内部类的一个对象： 
Parcel11.Contents c = p.new Contents(); 
// 除非已拥有外部类的一个对象，否则不可能创建内部类的一个对象

 

// 先是封装类的名字，再跟随一个$，
// 再跟随内部类的名字。
WithInner$Inner.class 
// 如果内部类是匿名的，那么编译器会简单地生成数字，把它们作为内部类标识符使用

 内部类：

1. 在单独一个类里表达一个控制框架应用的全部实施细节，从而完整地封装与那个实施有关的所有东西。内部类用与表达多种不同类型的的action，用于解决实际的问题。
2. 内部类使我们具体的实施变得更加巧妙，因为能方便地访问外部类的任何成员。