Java构造器和多态

最近复习Java的一些基础知识，看到构造器和多态这块，简单记录一下复习的内容

• 构造器
  构造器实际上是隐式声明的static方法，父类的构造器总是在子类的构造过程中被调用，而且按照继承层次逐渐向上，以使每个父类的构造器都能得到调用。这样做是有意义的，因为构造器具有一项特殊任务：检查对象是否被正确的创建。子类只能访问自己的成员和父类中的非私有成员，不能访问父类中的私有成员，只有父类的构造器才能恰当的对这些私有成员进行初始化，因此，每个子类都必须调用父类构造器，在子类的构造器中，如果没有明确指定调用某个父类构造器，那就会调用父类默认的构造器，如果父类不存在默认构造器（即父类仅创建了带有参数的构造器），编译器就会报错。（如果父类没有构造器，编译器会生成一个默认构造器）

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{
    private Cheese c = new Cheese();
    Lunch(){
        System.out.println("lunch()");
    }
}
class PortableLunch extends Lunch{
    private Bread b = new Bread();
    PortableLunch(){
        System.out.println("PortableLunch()");
    }
}
public class ConstructorDemo extends PortableLunch{
    
    private Bread b = new Bread();
    private Cheese c = new Cheese();
    private Lettuce l = new Lettuce();
    
    public ConstructorDemo(){
        System.out.println("ConstructorDemo()");
    }

    public static void main(String[] args) {
        new ConstructorDemo();
    }
}

运行结果如下：

Meal()
Cheese()
lunch()
Bread()
PortableLunch()
Bread()
Cheese()
lettuce()
ConstructorDemo()

上面例子以及输出我们可以看到执行顺序为：
1.调用父类构造器。这个步骤会不断反复递归下去，首先是构造这种层次结构的根，然后是下一层的子类，子类的子类......直到最后的子类。
2.按照声明顺序调用成员的初始化方法。
3.调用子类的构造器的主体。

• 多态

（1）什么是多态？

多态又分为 编译时多态和运行时多态。
编译时多态：比如重载。重载的特性：方法名相同，返回类型和传入方法的参数不同(包括个数和类型).
运行时多态：比如重写。重写的特性：方法名，返回类型，参数均相同，必须发生在子类。

（2）多态的实现机制

父类或接口的引用变量所指向的具体类型和通过该引用变量的方法调用在编程的时候并不确定，由于程序调用方法是在运行期才动态绑定的，那么引用变量所指向的具体实例对象在运行期才确定。这样不用修改源码就可以把变量绑定到不同的类实例上，让程序拥有了多个运行状态，这就是多态。
这个对象的方法是运行期正在内存运行的这个对象的方法而不是引用变量的类型中定义的方法，又因为子类可以继承父类中的非私有方法，可以重写了父类的某个非私有方法，所以运行在内存中的对象同时拥有着父类未被重写的方法以及子类中重写父类的方法和自身特有的方法。

但是向上转型存在一些缺憾，那就是它必定会导致一些方法和属性的丢失，而导致我们不能够获取它们。所以父类类型的引用可以调用父类中定义的所有属性和方法，对于只存在于子类中的方法和属性它就望尘莫及了。

（3）Java实现多态有三个必要条件：继承、重写、向上转型。

继承：在多态中必须存在有继承关系的子类和父类。
重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
向上转型：在多态中需要将子类的对象赋给父类引用，只有这样该引用才能够具备调用父类的方法和子类的方法。
只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。

再来看段代码示例：

class A {
    
    public String show(D obj) {
        return ("A and D");
    }

    public String show(A obj) {
        return ("A and A");
    } 

}

class B extends A{
    public String show(B obj){
        return ("B and B");
    }
    
    public String show(A obj){
        return ("B and A");
    } 
}

class C extends B{

}

class D extends B{

}

public class Polymorphism {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
        
        System.out.println("1--" + a1.show(b));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a1.show(d));
        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));
        System.out.println("7--" + b.show(b));
        System.out.println("8--" + b.show(c));
        System.out.println("9--" + b.show(d));      
    }
}

运行结果如下：

1--A and A
2--A and A
3--A and D
4--B and A
5--B and A
6--A and D
7--B and B
8--B and B
9--A and D

从上面的程序中我们可以看出A、B、C、D存在如下关系。

继承关系图

首先我们分析5，a2.show(c)，a2是A类型的引用变量，所以this就代表了A，a2.show(c),它在A类中找发现没有找到，于是到A的超类中找(super)，由于A没有超类（Object除外），所以跳到第三级，也就是this.show((super)O)，C的超类有B、A，所以(super)O为B、A，this同样是A，这里在A中找到了show(A obj)，同时由于a2是B类的一个引用且B类重写了show(A obj)，因此最终会调用子类B类的show(A obj)方法，结果也就是B and A。

按照同样的方法我也可以确认其他的答案。

方法已经找到了但是我们这里还是存在一点疑问，我们还是来看这句话：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。这我们用一个例子来说明这句话所代表的含义：

a2.show(b)；

这里a2是引用变量，为A类型，它引用的是B对象，因此按照上面那句话的意思是说有B来决定调用谁的方法,所以a2.show(b)应该要调用B中的show(B obj)，产生的结果应该是“B and B”，但是为什么会与前面的运行结果产生差异呢？这里我们忽略了后面那句话“但是这儿被调用的方法必须是在超类中定义过的”，那么show(B obj)在A类中存在吗？根本就不存在！所以这句话在这里不适用？那么难道是这句话错误了？非也！其实这句话还隐含着这句话：它仍然要按照继承链中调用方法的优先级来确认。所以它才会在A类中找到show(A obj)，同时由于B重写了该方法所以才会调用B类中的方法，否则就会调用A类中的方法。

所以多态机制遵循的原则概括为：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法，但是它仍然要根据继承链中方法调用的优先级来确认方法，该优先级为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。