《Java 编程思想》学习笔记 07 | 多态

1.动态绑定=后期绑定=运行时绑定

1. 绑定：将一个方法调用同一个方法体关联起来被称作绑定。
2. 动态绑定：在运行时，方法调用根据对象的类型(而不是引用的类型)与正确的方法体进行绑定。也叫后期绑定或运行时绑定。
3. Java中除了static方法和final方法(private方法也是final方法)之外，其它所有的方法都是后期绑定。
4. 要想实现动态绑定，就必须具有某种机制，以便在运行时能判断对象的类型，从而调用正确的方法，在这种机制中，不管怎样，都必须在对象中安置某种“类型信息”。
5. 动态绑定机制随编程语言的不同而有所不同，在Java中，编译器一直不知道对象的类型，但是方法调用机制能找到正确的方法体，并加以调用。

2.final方法是为了关闭动态绑定

一旦某一个父类中的方法被声明为final，那么在子类中就不能重写该方法，这样就使得调用该方法的时候只会去调用父类的这唯一一个版本，而不用去考虑还有没有其它什么版本可以调用。

这样做就使得该方法失去了动态绑定的机制：在编译时该方法就知道要调用哪一个类中的哪一个方法体，而不用去等到运行时根据动态绑定机制再去确定调用哪个类中的哪个方法体。

3.简单的向上转型：父类引用指向子类对象

Father f = new Child();

这里创建了一个子类对象，并把它赋值给一个父类引用，成功实现了向上转型。

4.多态

在上面的例子中，虽然f是父类的引用类型，但由于它指向的是子类的对象，所以，

1. 当用父类引用去调用某一个被子类重写了的同名方法时，方法调用中的动态绑定机制就会根据引用所指向的对象类型来判断到底调用的是父类的方法版本还是子类的方法版本。在这里，由于引用f指向的是子类的对象，所以自然调用的是子类的方法版本，这样，就实现了多态。

5.只有方法有多态，属性没有多态

因为多态是由动态绑定机制实现的，而方法和属性中，只有方法有动态绑定机制，属性没有这种机制，所以说：在Java中，只有方法有多态，属性没有多态。

class Father {
	public int i = 4; 
}
class Child extends Father {
	public int i = 5;
}
class Test {
	public static void main(String[] args) {
    	Father f = new Child(); 
        System.out.prirtln(f.i);
    }
}
/* 
* Output:
* 4
*/

所以，使用“父类引用指向子类对象”这种方式创建对象时，若用父类引用调用父类和子类的同名属性时，调用的其实是父类的属性，这一点要牢记，经常会忽略！

6.为什么static方法没有多态

这一点我其实也不是很清楚，只能死记一下了：静态方法是与类相关联的，当用父类引用去调用静态方法，那只能是调用父类的静态方法，而不会去调用子类对象的同名的静态方法，因为对静态方法来说，虽然在父类与子类中它们同名了，但它们是分别只属于父类和子类的，因为有向上转型的存在，也就是父类引用指向了子类对象，但静态方法看的只是父类的引用。

7.再探组合、继承、多态中的构造器与字段初始化的调用顺序

记住三句话：

1. 构造器调用之前，先进行字段初始化。
2. 基类构造器总是在子类构造器调用之前被调用。
3. 调用基类构造器之前先进行基类的字段初始化。

所以，总结来看：在一个三层继承的关系中，当new一个子类对象时(不管是爸爸类的引用指向子类对象也好，还是爷爷类的引用指向子类对象也好，都是根据new的那个子类对象来执行相应动作)，都是先执行爷爷类的字段初始化，然后调用爷爷类的构造器，接着执行爸爸类的字段初始化，然后执行爸爸类的构造器，接着执行子类的字段初始化，最后调用子类的构造器。

注意：如果有静态成员的话，先执行完爷爷爸爸孩子的所有静态初始化后再执行上面的动作。

class GrandFatherAttribute {
    GrandFatherAttribute() {
        System.out.println("GrandFatherAttribute()");
    }
}
class FatherAttribute {
    FatherAttribute() {
        System.out.println("FatherAttribute()");
    }
}
class ChildAttribute {
    ChildAttribute() {
        System.out.println("ChildAttribute()");
    }
}

class GrandFather {
    private GrandFatherAttribute gfa = new GrandFatherAttribute();
    GrandFather() {
        System.out.println("GrandFather()");
    }
}
class Father extends GrandFather {
    private FatherAttribute fa = new FatherAttribute();
    Father() {
        System.out.println("Father()");
    }
}
public class Child extends Father {

    private ChildAttribute bread = new ChildAttribute();

    Child() {
        System.out.println("Child()");
    }

    public static void main(String[] args) {
        Child child = new Child();
        System.out.println("---------------------");
        Child child1 = new Child(); //字段初始化还是要进行，因为是不同对象。
        System.out.println("---------------------");
        Father father = new Child(); //父类引用指向子类对象并没有改变什么，还是按照new的那个子类对象来执行相应动作。
    }
}

8.构造器内部的多态方法的行为

调用父类的构造器时，如果此时在父类构造器里面调用父类的某个被子类重写了的方法的话，调用的是子类中重写之后的版本，这是构造器内部的多态方法行为。

9.初始化的真正全过程

1. 执行默认初始化（将分配給对象的存储空间初始化成二进制的零）
2. 执行静态初始化
3. 执行父类的字段初始化
4. 调用父类的构造器（如果此时在父类构造器里面调用父类的某个被子类重写了的方法的话，调用的是子类中重写之后的版本，这是构造器内部的多态方法行为）
5. 执行子类的字段初始化
6. 调用子类的构造器

注：参考《Java编程思想》p162 8.3.3 构造器内部的多态方法的行为

10.在构造器内部应尽量避免调用其它方法

因为你很有可能会忽略掉“构造器内部的多态方法的行为”这一情况，从而导致一些灾难性事故。如果你确实想要在构造器内部调用其它方法，请确保该方法是final的（private也是final的），这样才不会出现“构造器内部的多态方法的行为”这一情况。

11.协变返回类型

协变返回类型是指：子类重写的方法的返回类型可以是父类方法的返回类型的导出类型。如：

class Father {
    Object f(){
        ...
    }
}
class Child {
    @Override
    String f(){ //返回类型String是Object的导出类型
        ...  
    }
}

12.状态模式：用继承展示行为间的差异，用组合表现状态上的变化

class Actor {
    public void act() {}
}
class HappyActor extends Actor {
    public void act() {
        System.out.println("HappyActor") //用继承展示行为间的差异
    }
}
class SadActor extends Actor {
    public void act() {
        System.out.println("SadActor") //用继承展示行为间的差异
    }
}
class stage {
    private Actor actor = new HappyActor(); //用组合表现状态上的变化
    public void change() {
        actor = new SadActor(); //让actor引用指向SadActor对象，做到状态的改变
    }
    public void performPlay() {
        actor.act();
    }
}
public class Transmogrify {
    public static void main(String[] args) {
        Stage stage = new Stage();
        stage.performPlay();
        stage.change();
        stage.performPlay();
    }
}
/*
* Output:
* HappyActor
* SadActor
*/

1. 通过继承得到了两个不同的类，用于表达act()方法的差异，而Stage通过运行组合使自己的状态可以发生变化，当状态发生变化时，行为也就随之进行改变。
2. 这样，就既使用到了继承，又使用到了组合，而且在状态模式中，组合表现得非常灵活，它可以动态地选择类型，也就产生了不同的行为，使我们可以在在运行时得到动态灵活性（即代码27行所展示出来的在运行时的动态灵活性）。

13.子类拓展父类接口的缺陷：向上转型后无法访问子类新拓展出来的方法

在实际开发中，我们通常需要在子类中写出一些新的父类没有的方法，但是当我们以“父类的引用指向子类的对象”这种方式来进行向上转型继而创建对象的话，此时，该父类的引用是无法访问子类新拓展出来的方法的。

class Useful {
    public void f() {}
}
class MoreUseful extends Useful {
    public void f() {}
    public void g() {}
}
public class RTTI { 
    public static void main(String[] args) {
        Useful u1 = new Useful();
        Useful u2 = new MoreUseful();
        u1.f(); //父类的f()
        u2.f(); //子类的f()
        u1.g(); //报错，父类没有g()方法
        u2.g(); //报错，父类引用无法访问子类新拓展出来的方法
    }
} 

所以，以后在看代码的时候要养成习惯：当出现以“父类引用指向子类对象”这种方式创建对象时，代码中如果出现用父类引用去调用方法时，应该下意识地先瞄向父类，看看父类有没有这个方法，然后再去看子类。