Java基础（六）——继承

1. 作用：
   a. 提高了代码的服用性。
   b. 让类与类之间产生了关系，有了这个关系，才有了多态的特性。

   注意：千万不要为了获取其他类的功能，简化代码而继承。
   必须时类与类之间有所属关系才可以继承，所属关系（is a)。
   

2. Java语言中，Java只支持单继承，不支持多继承。（一个孩子只能有一个孩子）
   因为多继承会带来安全隐患：当都多个父类中定义了相同的功能，当功能不同时，子类对象不去确定运行哪一个。
   但是Java保留这一种机制（多继承），并用另一种体现形式来实现，多实现。

   Java支持多层继承，也就是一个继承体系。

   如何使用一个继承体系中的功能呢？
   想使用体系，先查阅体系父类的描述，因为父类中的定义的是该体系中共性功能。
   通过了解共性功能，就可以知道该体系的基本功能。
   那么这个体系已经可以基本使用了，要创建最子类对象。
   为什么要创建最子类对象？
   a. 因为可能父类不能创建对象（抽象类）。
   b. 创建子类对象可以使用更多的功能，包括基本的也包括特有的。

   简单一句：查阅父类功能，创建子类对象使用功能。

3. 聚集，聚合，组合
   聚集：has a
   聚合：球队中的一员。
   组合：胳膊，腿，手是人的一部分

4. 子父类出现后，类成员的特点：
   子类中对了一个引用super（本身就有的this）
   私有成员只能本类访问，继承的子类也不能访问。
   类中成员：
     a. 变量
     b. 函数
     c. 构造函数

   a. 子父类中的变量：子类同时有this和super引用
   如果子类中出现非私有的同名成员变量时：
   子类要访问本类中的变量，用this（可以省略）
   子类要访问父类中的同名变量，用super。

   super的使用和this的使用几乎一致。
   this代表的是本类对象的引用，（可以省略）
   super代表的是父类对象的引用。

   b. 子父类中的函数：
   当子类出现和父类一摸一样的函数时，
   当子类对象调用该函数时，会运行子类函数的内容。
   如同父类函数被覆盖一样。

   这种情况是函数的另一个特性：重写（覆盖)。

   当子类继承父类，沿袭了父类的功能到子类中，但是子类虽然具备该功能，但是功能却和父类不一致。这是没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能的内容。

   覆盖：（一摸一样）

   1. 子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。
   2. 静态只能覆盖静态。
   3. 子类不能访问父类中的private。如果和父类中的private函数一样，子类不叫覆盖父类，而是子类特有函数，因为子类不知道父类有这样的函数。
   
   

   注意：
   重载：只看同名函数的参数列表
   重写：子父类方法要一摸一样，包括返回类型（且父类方法不能私有，子类访问不低于父类访问权限）

   c. 子父类中的构造函数

public class Fu {
    Fu()
    {
        System.out.println("fu run");
    }
}

class Zi extends Fu{
    Zi()
    {
        //super();         //父类的构造函数    可以省略，但是JVM自动加上
        //this();    //本类的构造函数
        System.out.println("zi run");
    }
}

class ExtendsDemo
{
    public static void main(String[] args) {
        Zi z = new Zi();
    }
}

在对子类对象进行初始化时，父类的构造函数也会运行，
那是因为子类的构造函数默认第一行有一条隐式的语句super();(调用父类的构造函数）
super()：会访问父类中空参数的构造函数，而且子类中所有的构造函数都会默认第一行都是super()；

public class Fu {
    Fu()
    {
        System.out.println("fu run");
    }
}

class Zi extends Fu{
    Zi()
    {
        //super();         //父类的构造函数    可以省略，但是JVM自动加上
        //this();    //本类的构造函数
        System.out.println("zi run");
    }
    Zi(int num)
    {
        System.out.println("zi..." + num);
    }
}

class ExtendsDemo
{
    public static void main(String[] args) {
        Zi z = new Zi();
        Zi z1 = new Zi(4);

    }
}

（子类一定要访问父类的构造函数）

public class Fu {
    Fu(int num)
    {
        System.out.println("fu run" + num );
    }
}

class Zi extends Fu{
    Zi()
    {
        super(4);         //父类构造函数有参数，则子类必须要有与之对应的构造函数，否则编译不通过, 
       	 //父类中没有无参构造函数，则没有默认构造函数，不能隐式调用父类构造函数，必须显式调用父类构造函数
        System.out.println("zi run");
    }
    Zi(int num)
    {
        super(2);
        System.out.println("zi..." + num);
    }
}

class ExtendsDemo
{
    public static void main(String[] args) {
        Zi z = new Zi();
        Zi z1 = new Zi(4);

    }
}

为什么子类一定要访问父类中的构造函数。
因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的，所以子类在对象初始化时，要先访问一下父类中的构造函数。
如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。

class Person
{
    private String name;
    Person(String name){
        this.name = name;
    }
    public void show()
    {
        System.out.println("name : "+ name);
    }
}

class Student extends Person
{
    Student(String name)
    {
        super(name);
    }
    public void method()
    {
        super.show();
    }
    
}

子类的实例过程：（逐级调用父类的构造函数，所有类必有父类Object）

super语句一定放在子类构造函数的第一行。this();调用自己的构造函数。
子类的所有的构造函数，默认都会访问父类中的空参数的构造函数。
因为子类中每一个构造函数类的第一行都有一句隐式super();

当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问的构造函数。
当然，子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数，子类中至少有一个构造函数会访问父类中的构造函数。
this和super不能同时出现，因为两个都要早构造函数的第一行。
为什么非要放在第一行？因为初始动作要先做

方法重写三个要点：
1. “==”：方法名、形参列表相同
2. “<=”：返回值类型和声明异常类型，子类小于等于父类。
3. “>=”：访问权限，子类大于等于父类。

子类构造函数第一行肯定有this或者super关键字调用本类或者父类的构造函数。没有写默认super();，调用父类无参构造函数

第一行只能是this()或者super()，且只能有一个