写在前面
最近开始回头重读《Thinking in Java》，把感兴趣的部分再仔细看一遍，顺便做做读书笔记。子曰：学而时习之，不亦说乎？
正文
“多态通过分离 做什么 和 怎么做 ，从另一个角度讲接口和实现分离开来”
“多态的作用是消除 类型 之间的耦合关系”
多态使得同一份代码可以不做任何改变就可以引用多种类的对象，代码只知道这些对象类的父类，至于这些对象所属的子类、这些子类的行为对这代码是完全透明的。这就省去了在代码中令人厌烦的用于判断对象类型的一堆if或者switch 语句。而当需求发生变化，需要引入更多的子类时，也不需要对这部分代码进行修改，这正符合“对修改关闭，对扩展开放”的原则。
“将一个方法调用同一个方法主体关联起来被称作 绑定”
“在运行时根据对象类型进行绑定。后期绑定也叫做动态绑定或运行时绑定。”
动态绑定是多态的实现方式。
Java中除了static方法、final方法、private方法（属于final方法）、构造方法（隐式声明的static方法）外，其他所有方法都是动态绑定的。
经常能看到如何提升Java代码性能的文章中提到尽可能声明final方法，因为这样编译器不需要考虑动态绑定，可以为final方法调用生成更有效的方法，但是书中说
“大多数情况下，这样做对程序的整体性能不会有什么改观。所以，最好根据设计来决定是否使用fianl，而不是出于试图提高性能的目的来使用final”。
关于动态绑定这一部分，经常见到这样的问题：
public class A {
public void show(C c){
System.out.println("A show C");
}
public void show(A a){
System.out.println("A show A");
}
public class C extends B{
public void show(A a){
System.out.println("C show A");
}
}
public class D extends B{}
public void test(){
A a=new A();
A b=new B();
B b1=new B();
C c=new A().new C();
D d=new A().new D();
b.show(b);//1
b.show(c);//2
b.show(d);//3
b1.show(b);//4
b1.show(d);//5
c.show(d);//6
}
}
public class B extends A{
public void show(B b){
System.out.println("B show B");
}
public void show(C c){
System.out.println("B show C");
}
public static void main(String[] args){
new A().test();
}
}
运行B的main方法，打印结果是？
A show A
B show C
A show A
A show A
B show B
B show B
相信很多人和我一样，自信满满拿出笔，潇洒的写出答案，然后一对比，错了一半……
这个问题涉及到动态绑定时，方法的查找规则。
对于一个方法foo(arg)，方法搜索的过程按照foo(arg)àsuper.foo(arg)àfoo((super)arg)àsuper.foo((super)arg)这一顺序进行.
接下来针对上面的输出一个个说明。
- b.show(b)，b的类型为A，引用了B的对象，根据搜索顺序，先找A.show(A)方法，在A中存在这一方法，虽然A引用了B的对象，但是B中并没有show(A)方法覆盖A.show(A)，所以执行A.show(A)方法，打印“A show A”。
- b.show(c)，b的类型为A，引用了B的对象，根据搜索顺序，先找A.show(C)方法，在A中存在这一方法，但是先别着急，因为A引用了B的对象，而B中也有方法show(C)，覆盖了A中的方法，因此实际上执行的是B.show(C)方法，打印“B show C”。
- b.show(d)，b的类型为A，引用了B的对象，根据搜索顺序，先找A.show(D)，没有找到；接下来由于A没有父类了，super.foo(arg)不需要搜索；然后是foo((super)arg)，D继承自B，查找A.show(B)方法，依然没有；然后是super.foo((super)arg)，由于A没有父类，不需要搜索；这时，好像搜索已经结束了，其实不然，由于super.foo(arg)不存在，foo((super)arg)会替代当前foo(arg)，继续上面的流程。也就是说对方法A.show(B)继续走一遍搜索流程，这一次可以找到方法A.show(A)符合要求，可以执行，打印“A show A”。
- b1.show(b)，b1类型为B引用B的对象，b的类型为A引用B的对象，首先找B.show(A)，没有找到；接下来找super.foo(arg)，B继承自A，而A.show(A)方法是存在的，打印“A show A”。
- b1.show(d),b1类型为B引用B的对象，d的类型为D引用D的对象，首先找B.show(D)，没有找到；接下来找super.foo(arg)，同样没有A.show(D);接下来是foo((super)arg)，D继承自B，B.show(B)是存在的，可以执行，打印“B show B”。
- c.show(d)，c类型为C引用C的对象，d的类型为D引用D的对象，首先找C.show(D)，没有找到；接下来找super.foo(arg)，C继承自B，B.show(D)同样不存在，B继承自A，而A.show(D)也不存在，没有找到；接下来找foo((super)arg)，D继承自B，C.show(B)不存在，没有找到；接下来是super.foo((super)arg)，即B.show(b)，方法存在，可以执行，打印“B show B”。
“用继承表达行为间的差异，用字段表达状态上的变化”
这个原则是作者在讲述在设计中选择继承还是组合时提出的。当你不确定应该选择哪种方式时，优先考虑组合。不合理的继承会加重设计的负担，增加不必要的复杂性；相反组合不会强制设计与类型层次结构耦合，设计更加灵活。
