旅（9）多态性
多态性是继数据抽象和继承后，面向对象语言的第三个特征。
绑定（binding）（看起来到像一个音译词）：将方法的调用连到方法本身被称为绑定，当绑定发生在程序运行之前，被称做前绑定（earlybinding）,而在程序运行的时候根据对象的类型来决定该绑定方法的成为后绑定，也叫运行时绑定（run-time binding）或动态绑定（dynamic binding）；java的所有方法都采用后绑定，也就是说通常情况下，
你不用考虑是不是该采用后绑定，这一切都是自动的。
有一个经典的关于形状的例子，可以生动的说明什么是后绑定。
在这个例子中，基类是shape类，它有几个派生类：circle, Square, Triangle,
Shape s = new Circle();
这里先创建了一个Circle对象，接着把它给了一个Shape，看上去这样做有点不妥，不过确是不错的，因为Circle确实也是个Shape，接着假设你调用了一个基类的方法
s.draw();
可能你会认为这次调用的应该是shape的draw方法吧，然而不是，它调用的却是circle的draw(),这就是因为实现的后绑定的原因。具体的实现方法就是基类定义了一个共用的接口――也就是说所有的shape都有draw()方法和erase（）方法，派生类会覆写这两个方法从而提供不同的行为。到这里我想为什么不直接写成：
Circle s = new Circle();
s.draw();
后来看到作者将这个例子改动成随机的创建一个Circle, Square, Triangle对象，因为这时还不知道创建的对象具体是什么，所以只有像前面的那样的写法利用动态绑定才能实现。
由此我们看到了多态性的最大优势：可扩展性。我们可以根据需要添加任意个新的类型，而不用担心修改基类里的方法，因此在一个设计良好的OOP程序里，绝大多数方法都会和draw()方法一样，只跟基类接口打交道。这种程序是可扩展的，因为你可以通过让新的数据类型继承通用的基类的方法来添加新的功能。而那些与基类接口打交道的方法，根本不需要做修改就能适应新的类。
对程序员来说，多态性是一项非常重要的技术，它能让你将会变的和不会变的分隔开来。
抽象类和抽象方法：要创建像shape类这样的类对象是没有实际意义的，更何况你可能还要阻止用户这么做，这样我们可以使用抽象方法来解决这个问题。形如：
abstract void f();
而包含一个或多个抽象方法的类就是抽象类（含有抽象方法是必须被定义位抽象类的），抽象类的作用是通过一个公共的接口来操控一组类。它的方法就像上面例子里基类的方法一样，只是样子货。而且如果创建一个抽象类的对象，编译器就会报错。
如果你继承了抽象类，并打算创建该类的对象，那就必须实现基类所定义的全部方法，否则有一个抽象方法存在的话，那么该类还是个抽象类。
创建一个不包含抽象方法的抽象类是可以的，这种技巧可以用于不必创建抽象方法，但又想禁止别人创建这个类的对象的场合。
构造函数总是与众不同，牵涉到多态性也不例外。首先研究一个例子，复习一下构造函数的调用顺序先。
///////////////////////////////////////////////////////////////////////////////////
class Meal {
Meal() { System.out.println("Meal()"); }
}
class Bread {
Bread() { System.out.println("Bread()"); }
}
class Cheese {
Cheese() { System.out.println("Cheese()"); }
}
class Lettuce {
Lettuce() { System.out.println("Lettuce()"); }
}
class Lunch extends Meal {
Lunch() { System.out.println("Lunch()"); }
}
class PortableLunch extends Lunch {
PortableLunch() { System.out.println("PortableLunch()");}
}
public class Sandwich extends PortableLunch {
private Bread b = new Bread();
private Cheese c = new Cheese();
private Lettuce l = new Lettuce();
public Sandwich() {
System.out.println("Sandwich()");
}
public static void main(String[] args) {
new Sandwich();
System.out.println("正确输出：");
System.out.println(
"Meal()\n"+
"Lunch()\n"+
"PortableLunch()\n"+
"Bread()\n"+
"Cheese()\n"+
"Lettuce()\n"+
"Sandwich()"
);
}
}
///////////////////////////////////////////////////////////////////////////
也就是说复杂对象的构造函数的调用顺序是这样的：
1， 调用基类的构造函数。这是一个递归的过程，因此会先创建继承体系的根，然后是下一级派生类，以次类推直到最后一个继承类的构造函数。
2， 成员对象按照其声明的对象顺序进行初始化。
3， 执行继承类的构造函数的正文。
关于清理工作，虽不常用，但是个非常需要小心的工作。
一个好的构造函数应该，用最少的工作量把对象的状态设置好，而且要尽可能的避免去调用方法构造函数唯一能安全调用的方法就是基类的final方法。（这一条也同样适用private,因为它自动就是final）他们不会覆写，因此也不会产生这种意外的行为。
待续。。。。。。
多态性是继数据抽象和继承后，面向对象语言的第三个特征。
绑定（binding）（看起来到像一个音译词）：将方法的调用连到方法本身被称为绑定，当绑定发生在程序运行之前，被称做前绑定（earlybinding）,而在程序运行的时候根据对象的类型来决定该绑定方法的成为后绑定，也叫运行时绑定（run-time binding）或动态绑定（dynamic binding）；java的所有方法都采用后绑定，也就是说通常情况下，
你不用考虑是不是该采用后绑定，这一切都是自动的。
有一个经典的关于形状的例子，可以生动的说明什么是后绑定。
在这个例子中，基类是shape类，它有几个派生类：circle, Square, Triangle,
Shape s = new Circle();
这里先创建了一个Circle对象，接着把它给了一个Shape，看上去这样做有点不妥，不过确是不错的，因为Circle确实也是个Shape，接着假设你调用了一个基类的方法
s.draw();
可能你会认为这次调用的应该是shape的draw方法吧，然而不是，它调用的却是circle的draw(),这就是因为实现的后绑定的原因。具体的实现方法就是基类定义了一个共用的接口――也就是说所有的shape都有draw()方法和erase（）方法，派生类会覆写这两个方法从而提供不同的行为。到这里我想为什么不直接写成：
Circle s = new Circle();
s.draw();
后来看到作者将这个例子改动成随机的创建一个Circle, Square, Triangle对象，因为这时还不知道创建的对象具体是什么，所以只有像前面的那样的写法利用动态绑定才能实现。
由此我们看到了多态性的最大优势：可扩展性。我们可以根据需要添加任意个新的类型，而不用担心修改基类里的方法，因此在一个设计良好的OOP程序里，绝大多数方法都会和draw()方法一样，只跟基类接口打交道。这种程序是可扩展的，因为你可以通过让新的数据类型继承通用的基类的方法来添加新的功能。而那些与基类接口打交道的方法，根本不需要做修改就能适应新的类。
对程序员来说，多态性是一项非常重要的技术，它能让你将会变的和不会变的分隔开来。
抽象类和抽象方法：要创建像shape类这样的类对象是没有实际意义的，更何况你可能还要阻止用户这么做，这样我们可以使用抽象方法来解决这个问题。形如：
abstract void f();
而包含一个或多个抽象方法的类就是抽象类（含有抽象方法是必须被定义位抽象类的），抽象类的作用是通过一个公共的接口来操控一组类。它的方法就像上面例子里基类的方法一样，只是样子货。而且如果创建一个抽象类的对象，编译器就会报错。
如果你继承了抽象类，并打算创建该类的对象，那就必须实现基类所定义的全部方法，否则有一个抽象方法存在的话，那么该类还是个抽象类。
创建一个不包含抽象方法的抽象类是可以的，这种技巧可以用于不必创建抽象方法，但又想禁止别人创建这个类的对象的场合。
构造函数总是与众不同，牵涉到多态性也不例外。首先研究一个例子，复习一下构造函数的调用顺序先。
///////////////////////////////////////////////////////////////////////////////////
class Meal {
Meal() { System.out.println("Meal()"); }
}
class Bread {
Bread() { System.out.println("Bread()"); }
}
class Cheese {
Cheese() { System.out.println("Cheese()"); }
}
class Lettuce {
Lettuce() { System.out.println("Lettuce()"); }
}
class Lunch extends Meal {
Lunch() { System.out.println("Lunch()"); }
}
class PortableLunch extends Lunch {
PortableLunch() { System.out.println("PortableLunch()");}
}
public class Sandwich extends PortableLunch {
private Bread b = new Bread();
private Cheese c = new Cheese();
private Lettuce l = new Lettuce();
public Sandwich() {
System.out.println("Sandwich()");
}
public static void main(String[] args) {
new Sandwich();
System.out.println("正确输出：");
System.out.println(
"Meal()\n"+
"Lunch()\n"+
"PortableLunch()\n"+
"Bread()\n"+
"Cheese()\n"+
"Lettuce()\n"+
"Sandwich()"
);
}
}
///////////////////////////////////////////////////////////////////////////
也就是说复杂对象的构造函数的调用顺序是这样的：
1， 调用基类的构造函数。这是一个递归的过程，因此会先创建继承体系的根，然后是下一级派生类，以次类推直到最后一个继承类的构造函数。
2， 成员对象按照其声明的对象顺序进行初始化。
3， 执行继承类的构造函数的正文。
关于清理工作，虽不常用，但是个非常需要小心的工作。
一个好的构造函数应该，用最少的工作量把对象的状态设置好，而且要尽可能的避免去调用方法构造函数唯一能安全调用的方法就是基类的final方法。（这一条也同样适用private,因为它自动就是final）他们不会覆写，因此也不会产生这种意外的行为。
待续。。。。。。
