“我曾经被问到’求教，Babbage先生，如果你向机器中输入错误的数字，可以得到正确的答案吗？’我无法恰当地理解产生这种问题的概念上地混淆” ——Charles Babbage(1791-1871)
再面向对象地程序设计语言中，多态是继数据抽象和继承之后的第三种基本特征。
“封装”通过合并特征和行为来创建新的数据类型。”实现隐藏”则通过讲细节”私有化”把接口和实现分离开来。继承允许将对象视为它自己本身的类型或其基类类型来处理。多态方法调用允许一种类型表现出与其他相似类型之间的区别，只要它们都是从同一基类导出来的。这种区别是根据方法行为的不同表现出来的，虽然这些方法都可以通过同一个基类来调用。
继承与多态：
继承：类与类之间的关系
多态：方法行为的不同表现
8.1 再论向上转型
对象既可以作为它自身的类型使用，也可以作为它的基类使用。
public enum Note{}
class Obj{
public void play(Note n){
System.out.println("Obj.play()");
}
}
class A extends Obj{
public void play(Note n){
System.out.println("A.play()");
}
}
class M{
public static void tune(Obj o){ // 提供向上转型方法
o.play(Note);
}
public static void main(String[] args){
A a = new A();
tune(a); // 向上转型，将A转为Obj
}
}
M.tune()可以接受Obj类型，也可以接受任何导出自Obj的类。
忘记对象的类型，只记住它们的基类。
class B extends Obj{
public void play(Note n){
System.out.println("B.play()");
}
}
class C extends Obj{
public void play(Note n){
System.out.println("C.play()");
}
}
class M{
public static void tune(A o){ // 为每一个新Obj导出类编写方法
o.play(Note);
}
public static void tune(B o){
o.play(Note);
}
public static void tune(C o){
o.play(Note);
}
public static void main(String[] args){
A a = new A();
B b = new B();
C c = new C();
tune(a);
tune(b);
tune(c);
}
}
可以这样做，但有一个主要缺点：必须为每一个新Obj类编写特定代码。
8.2 转机
观察tune()方法：
public static void tune(Obj o){
o.play(Note);
}
接受一个Obj引用，编译器怎么知道这个Obj是A还是B？
将一个方法调用同一个方法主体关联起来被称作绑定。
上述程序疑问，主要是因为前期绑定。解决的办法就是后期绑定，它的含义就是在运行时根据对象的类型进行绑定。就是说，编译器一直不知道类型，但是方法调用机制能找到正确的方法体，并加以调用。
Java中除了static方法和final方法（private属于final）之外，其他所有的方法都是后期绑定。通常我们不必判断，因为它会自动发生。
了解Java所有方法都是通过动态绑定实现多态之后，就可以只编写与基类打交道的程序代码了。
在编译时，编译器不需要获得任何特殊信息就能进行正确调用。
只有非private方法才能被覆盖，但是还需要注意覆盖private方法的现象，重写的private是全新的方法。
多态只适用于普通方法，不适用于类成员变量。
静态方法不具有多态性，静态方法是与类，而非与单个的对象相关联。
8.3 构造器和多态
尽管构造器并不具有多态性（实际上是隐式static方法），但了解构造器的运作有助于避免一些困扰。
基类构造器总是在导出类构造过程中被调用，而且按照继承层次逐渐向上，因为构造器有一项特殊任务：检查对象是否被正确构造。导出类只能访问自己的成员，基类成员通常是private，只有基类构造器才能恰当的对自己的元素进行初始化。因此必须另所有构造器都得到调用，否则就不可能正确构建完整对象。
构造器调用顺序：
如果在一个构造器的内部调用正在构造的对象的某个动态绑定（重写）方法，那会发生什么情况？
当在基类构造器中调用导出类重写过的方法，实际运行的是导出类的方法，并且这个导出类的成员可能还未初始化。
构造器中唯一安全调用的方法是基类中final（final包括private）方法，因为这些方法不能被覆盖。
class A{
void draw(){System.out.println("A.draw()");}
A(){
System.out.println("A() bdfore draw()");
draw(); // 基类中多态调用，实际执行B.draw()方法
System.out.println("A() after draw()");
}
}
class B extends A{
private int radius = 1;
B(int r){
radius = r;
System.out.println("B.B(), radius = " + radius); //初始化完成，构造器赋值radius=5
}
void draw(){
System.out.println("B.draw(), radius = " + radius);
}
}
public class M{
public static void main(String[] args){
new B(5);
}
}
A() bdfore draw()
B.draw(), radius = 0 // 基类调用的实际是导出类多态方法，此时导出类成员还未初始化完成
A() after draw()
B.B(), radius = 5 // 此时整个初始化完成
前一节讲述的初始化顺序并不十分完整，初始化实际过程是：
8.4 用继承进行设计
用继承表达行为间的差异，并用字段表达状态上的变化。
更好的方式是首先选择”组合”，尤其是不能十分确定应该使用哪一种方式时，组合不会强制我们的程序设计进入继承的层次结构。
class O{
public void act(){}
}
class A extends O{
public void act(){System.out.println("A...");}
}
class B extends O{
public void act(){System.out.println("B...");}
}
class S{
// 组合
private O o = new A();
public void change(){o = new B();}
public void performPlay(){o.act();}
}
public class M{
public static void main(String[] args){
S s = new S(); // S 成员初始化是 A
s.performPlay(); // S 调用默认是 A
s.change(); // S 修改状态为 B
s.performPlay(); // S 成员变成 B
}
}
A...
B...
通过继承得到两个不同的类，用于表达act()方法的差异；而S通过运用组合是自己的状态发生变化，这种情况下，这种状态的改变也产生了应为的改变
8.5 向下转型和运行时类型识别
Java中所有转型都会得到检查！
8.6 总结
多态意味着”不同的形式”。在面向对象程序设计中，我们持有从基类继承而来的相同接口，以及使用该接口的不同形式：不同版本的动态绑定方法。
Original: https://www.cnblogs.com/wei-ran/p/16059361.html
Author: 蔚然丶丶
Title: [Java编程思想] 第八章 多态
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/569886/
转载文章受原作者版权保护。转载请注明原作者出处！