目录
Java编程思想（一）第1~4章：概述
Java编程思想（二）第5章：初始化和清理
Java编程思想（三）第6章：访问权限
Java编程思想（四）第7章：复用类
Java编程思想（五）第8章：多态
Java编程思想（六）第9章：接口
Java编程思想（七）第10章：内部类
Java编程思想（八）第11章：持有对象
Java编程思想（九）第12章：异常
Java编程思想（十）第13章：字符串
第8章 多态（Polymorphism）
多态：也称作动态绑定、后期绑定或运行时绑定。
OOP编程的三个基本特征：数据抽象、继承（复用）、多态。
8.1 方法调用绑定（Method-call binding）
将一个方法调用与一个方法主体关联起来称作绑定。Connecting a mehtod call to a mehtod body is called binding.
前期绑定：在程序执行前进行绑定（如果有的话，由编译器和连接程序实现）。
它是面向过程语言中不需要选择就默认的绑定方式。例如，C只有一种方法调用，那就是前期绑定。
When binding is performed before the program is run (by the compiler and linker, if there is one), it’s called early binding. You might not have heared the term before because it has never been an option with procedural language. C compilers have only one kind of method call, and that’s early binding.
后期绑定：就是在运行时根据对象的类型进行绑定。后期绑定也叫做动态绑定或运行时绑定。
如果一种语言想实现后期绑定，就必须具有某种机制，以便在运行时能判断对象的类型，从而调用恰当的方法。也就是说，编译器一直不知道对象的类型，但是方法调用机制能找到正确的方法体，并加以调用。
The solution is called late binding, which means that the binding occurs at run time, based on the type of object. Late binding is also called dynamic binding or runtime binding. When a language implements late binding, there must be some mechanism to determine the type of the object at run time and to call the appropriate method. That is, the compiler still doesn’t know the object type, but the mehtod-callmechanism finds out and calls the correct method body. The late-binding mechanism varies from language to language, but you can imagine that some sort of type information must be installd in the objects.
再谈final方法（非多态）：
如Chapter7所说，final方法可以防止其他人覆盖该方法。但更重要的一点是：这样做可以有效地“关闭”动态绑定，或者说，告诉编译器不需要对其进行动态绑定。
Why would you declare a method final? As noted in the last chapter, it prevents anyone from overriding that method. Perhaps more important, it effectively “turns off” dynamic binding, or rather it tells the compiler that dynamic binding isn’t necessary.This allows the compiler to generate slightly more efficient code for final method calls. However, in most cases it won’t make any overall performance diffeence in your program, so it’s best to only use final as a design decision, and not as an attempt to improve performance.
8.2 域与静态方法（非多态）
域是不具有多态性的，只有普通的方法调用是多态的。
如果直接访问某个域，这个访问就将在编译期进行解析，即域是静态解析的。
eg: 当Sub对象转型为Super引用时，任何域访问操作都将由编译器解析，因此不是多态的。Super.field和Sub.field分配了不同的存储空间。这样，Sub实际上包含两个称为field的域：它自己的和它从Super处得到的。
静态方法也不具有多态性的。
如前文所述，静态方法是与类，而非与单个的对象相关联的。
8.3 构造器内部的多态方法的行为（慎用！）
如果在构造器内部调用正在构造的对象的某个动态绑定方法，由于动态绑定是在运行时才决定的，而此时，该对象还正在构造中，所以它不知道自己属于哪个类（父类还是自己），并且方法所操纵的成员可能还未进行初始化，这可能会产生一引起难于发现的隐藏错误。
8.3.1 构造器编码原则：
1. 尽可能的简单的方法，慎用重载方法；
2. 安全调用：使用final或private方法；
8.3.2 协变返回类型（Java SE5新增）：
允许@override的重写方法，可以返回super.method()的return类型的派生类型。
8.4 初始化的实际顺序（由内到外&递归方式执行构造！）
step1: 在其他任何事物发生之前，将分配给对象的存储空间初始化成二进制的零。
step2: 调用父类的构造过程（递归方式：同派生类的step1&2&3&4）。
step3: 按照声明的顺序调用成员变量的初始化。
step4: 调用导出类（派生类）的构造器主体。
8.5 继承和清理的顺序
8.5.1 构造&普通方法的区别：
构造方法：可不主动调用super.构造()，如显式调用，需要放在构造方法第一行；
普通方法：需自行主动调用super.method()，否则不会自动执行！
8.5.1 构造&清理顺序的区别：
构造初始化：先执行super.构造()，再执行派生类的构造方法；
清理（相反）：先执行派生类的清理方法，再执行基类的清理方法；（WHY？？？）
8.6 用继承进行设计
继承：编译时，已确定具体类型；
组合：更灵活的编码设计（建议优先选择），非写死的代码层次结构；
8.6.1 纯继承&扩展
方式1：纯继承（is-a）：
特征：只@override 基类已有的方法：super.method()，不新增其他方法；
优点：向上转型是安全的（子类不含额外信息）。
方式2：扩展继承（is-like-a）：
特征：派生类 新增其他方法；
优点：向上转型时会丢失子类信息（子类含额外信息）。
8.6.2 向下&向上转型和RTTI：
向上转型（downcasting）：安全的，类似于基本数据类型的窄向转换；
向下转型（upcasting）：不安全的，类似于基本数据类型的宽向转换（可能会调用到super中并不存在的方法）；
RTTI: Runtime type indentification（运行时类型识别），Java中所有的类型转换（casting）都会执行，异常时throws ClassCastException.
