java 对象实例化过程

package com.andy.monday;

public class Demo_Extends {

    public static void main(String[] args) {
        //Student s=new Student();
        Student s=new Student("jack");
    }

}
/**
 * 父类
 * */
class Person{
    protected String name="andy";
    protected int age;
    public Person(){
        System.out.println("Person run...");
    }
    /**
     * 如果提供了带参构造函数，而没有显示地提供无参构造函数的话，
     * 在创建子类对象的过程，编译会失败？为什么？
     * 因为子类的每一个构造函数的第一行都隐式地调用super();语句
     * 而我们又没有在父类中定义无参的构造函数，这样编译器就会提示
     * 找不到父类的无参构造函数，那这种情况，可以通过以下两种方式解决
     * 1.在父类中显示地定义一个无参的构造函数
     * 2.在子类的构造函数中显示地通过super语句调用带参的父类构造函数
     * 如：super(name);
     * */
    public Person(String name){
        this.name=name;
        System.out.println("Person name="+name);
    }
    
    public Person(String name,int age){
        this(name);
        this.age=age;
    }
    public void show(){
        System.out.println("Person show name:"+name);
    }
    
}

class Student extends Person{
    /**这个成员字段会隐藏父类的相同名称的成员变量
     * 那么如果想要在子类中访问到父类同名的成员变量
     * 可以通过super.name的方式来访问（在堆中创建的
     * 对象中有有两个name一个是父类的name一个是子类的name）
     * */
    protected String name="jack";
    /**
     * 根据重写的特点我们可以知道构造函数是不能重载的
     * 但是当我们这样定义一个子类的对象的时Student s= new Student();
     * 子类的实例化过程是怎么样的呢？
     * 我们通过结果：Person run...
                    Student run...
           来分析一下，说明在创建子类对象的时候，先调用了父类的无参构造函数
           然后再调用子类的构造函数，这是为什么呢？
           因为子类的每一个够函数隐式地在第一行有一句super();调用父类的无参构造函数
           为什么要添隐式添加super();呢？
           因为子类在继承父类的时候，将父类的成员数据也继承了过来，如果子类要使用这些数据的话
           就必须要先去父类中初始化这些数据，然后在根据需求在子类中再对这些数据进行初始化，也就
           说先要去参考父类的初始化结果。
     * */
    public Student(){
        //super();这个是jvm隐式添加上去的
        //super("andy");//在父类没有提供无参的构造函数时候，这样显示地调用带参的其他的父类构造函数
        System.out.println("Student run...");
    }
    
    public Student(String name){
        super(name);//注意显示指定的时候，一定要放在第一句
        System.out.println("Student name:"+name);
    }
    public Student(String name,int age){
        /**这个方式不是最佳的，应该要通过super(name,age);
         * 但是为了说明一下问题：
         * 首先调用this语句调用子类中的其他的构造函数的时候，
         * 该构造函数就不再隐式地调用super();语句，因为this语句与
         * super语句都必须要放在第一行（因为要先进行初始化的操作）
         * 那又为什么可以这样用呢？因为子类的构造函数总会有一个在调用
         * 父类的构造函数进行初始化要不就是隐式地super();要不就是显示地super
         * */
        
        this(name);
        this.age=age;
    }
    /**
     * 该函数是在重写（覆盖）父类同名的show方法（注意父类中的同名方法还在内存中）
     * 原则：子类要重写父类的同名方法是定义要一致，内部实现的内容不一致
     * 子类的重写方法要和父类的方法定义一模一样，连返回值也要一样的
     * 注意：子类中重写的父类方法，必须要保证子类的重写方法的访问权限大于等于
     * 父类的被重写的方法的权限，否则，编译失败
     * 同样，如果要使用父类的同名成员函数，可以过super.show();的方式进行访问
     * */
    public void show(){
        System.out.println("Student show name:"+name);
    }
}