继承篇 

为什么需要继承？

Java中使用类对现实世界中实体来进行描述，类经过实例化之后的产物对象，则可以用来表示现实中的实体，但是现实世界错综复杂，事物之间可能会存在一些关联，那在设计程序时就需要考虑。比如：狗和猫，它们都是一个动物。我们现在就可以创建一个猫类和狗类。

class Dog{
    public String name;
    public int age;
    //构造方法来初始化成员变量
    public Dog(String name, int age){
         = name;
        this.age = age;
    }
    //来打印成员变量
    public void show(){
        System.out.println("name:"++"age:"+this.age);
    }
}

class Cat{
    public String name;
    public int age;
    //构造方法来初始化成员变量
    public Cat(String name, int age){
         = name;
        this.age = age;
    }
    //来打印成员变量
    public void show(){
        System.out.println("name:"++"age:"+age);
    }
}

有细心的小伙伴会发现，这两个类有很多共同之处：成员变量，show方法。因此Java就提出了继承的概念，把共同的代码放到一起组成一个新的类。 继承是专门用来进行共性抽取，实现代码复用。

继承概念

继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。

我们还是拿上面的例子，狗和猫都是动物，那么我们就可以将共性的内容进行抽取，然后采用继承的思想来达到共用。

继承的语法

在Java中如果要表示类之间的继承关系，需要借助extends关键字，具体如下：

class 子类 extends 父类 {
    // ... 
}

那么上面的代码就可以改成下面这样：

class Animol{
    //这些成员变量和成员方法都是Dog和Cat共有的，因此放到父类
    public String name;
    public int age;
    public void show(){
        System.out.println("name:"++"age:"+age);
    }
}
//    子类 extends 父类
class Dog extends Animol{

    //构造方法来初始化成员变量
    public Dog(String name, int age){
         = name;
        this.age = age;
    }
}

//    子类 extends 父类
class Cat extends Animol{

    //构造方法来初始化成员变量
    public Cat(String name, int age){
         = name;
        this.age = age;
    }
}

注意：1. 子类会将父类中的成员变量或者成员方法继承到子类中 2. 子类继承父类之后，必须要新添加自己特有的成员，体现出与父类的不同，否则就没有必要继承了（这是在实际应用当中，而我们上面的代码只是演示，因此就不需要满足。如果是在写一个项目就需要满足上面的条件）。

父类成员访问

在继承体系中，子类将父类中的方法和字段（成员变量）继承下来了，那在子类中能否直接访问父类中继承下来的成员呢？下面我们就来学习在子类中访问父类成员和方法。

class Animol{
    public String name;
    public int age;
}

class Dog extends Animol{
    public String character;
    public void method() {
        name = "dabai"; // 访问从父类中继承下来的name
        age = 5; // 访问从父类中继承下来的age
        character = "忠诚"; // 访问子类自己的character
    }
}

但是还有一种情况：当子类的变量名和父类的变量名冲突时，优先访问子类的变量。

class Animol{
    public String name;
    public int age;
}

class Dog extends Animol{
    public String name;
    public void method() {
        name = "dabai"; // 访问子类自己的name
        age = 5; // 访问从父类中继承下来的age
    }
}

在子类方法中或者通过子类对象访问成员时： 如果访问的成员变量子类中有，优先访问自己的成员变量。 如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。 如果访问的成员变量与父类中成员变量同名，则优先访问自己的。 成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

public class Test {
    public static void main(String[] args){
        Dog dog = new Dog();
        dog.show();
    }
}

class Animol{
    public String name = "dabai";
    public int age = 5;
}

class Dog extends Animol{
    public String name = "huahua";
    public void show(){
        //由于编译器会默认加上this，因此我们写了也没问题，不是因为这个引起的，
        //但是如果我们把这个show方法放到Animol，那么就会打印dabai，
        //因为this是指向当前对象的引用
        System.out.println("name:"++" age:"+this.age);
    }
}

如果把show方法放到Animol中会不会发生我们所预料的情况呢？ 

从上面的结果来看我们的猜测是对滴。这样的结果就是this造成的。

同样成员方法的访问也是如此：成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时再到父类中找，如果父类中也没有则报错；反之，通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。 通过子类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错。

总结：父类成员的访问就是一句话，先在子类找，子类没找到，就找父类，都没找到就报错。（当父类方法与子类方法形成重载时，通过传递的参数来进行区分，但如果在子类中要访问重写的基类方法，则需要借助super关键字，重写后面在学习） 

但如果子类中存在与父类中相同的成员时，那如何在子类中访问父类相同名称的成员呢？Java就提供了super这个关键字来访问父类成员。

super关键字

由于设计不好，或者因场景需要，子类和父类中可能会存在相同名称的成员，如果要在子类方法中访问父类同名成员时，该如何操作？直接访问是无法做到的，Java提供了super关键字，该关键字主要作用：在子类方法中访问父类的成员。

public class Test {
    public static void main(String[] args){
        Dog dog = new Dog();
        dog.show();
    }
}

class Animol{
    public String name = "dabai";
    public int age = 5;
}

class Dog extends Animol{
    public String name = "huahua";
    public void show(){
        System.out.println("name:"++" age:"+super.age);
    }
}

注意：super只能在非静态方法中使用。因为super也是要依赖与对象。  

子类构造方法

父子父子，先有父再有子，即：子类对象在构造时，需要先调用父类构造方法，然后执行子类的构造方法。

class Animol{
    public String name = "dabai";
    public int age = 5;
    //因为我们没有写构造方法，编译器默认提供一个不带参数的构造方法
}

class Dog extends Animol{
    public String name = "huahua";
    public Dog(String name, int age){
        //因为我们没有写super（）这个构造方法，
        //编译器会自动把这个方法写到子类构造方法的第一行，就像下面这样
        //super();    //父类的构造方法一定要放到子类构造方法的第一行
        //我们也可以选择把super（）这个方法手动加到第一行
         = name;
        this.age = age;
    }
}

下面是部分错误的示例： 

在子类构造方法中，并没有写任何关于父类构造的代码，但是在构造子类对象时，先执行父类的构造方法，然后执行子类的构造方法，是因为：子类对象中成员是有两部分组成的，父类继承下来的以及子类新增加的部分 。父子父子 肯定是先有父再有子，所以在构造子类对象时候 ，先要调用父类的构造方法，将从父类继承下来的成员构造完整 ，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整。

注意： 1. 若父类显式定义无参或者使用默认的构造方法（即没写构造方法），在子类构造方法第一行默认有隐含的super()调用，即调父类构造方法 2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。 3. 在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。 4. super(...)只能在子类构造方法中出现一次，并且不能和this同时出现 。

super和this的比较

super和this都可以在成员方法中用来访问：成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句，那他们之间有什么区别呢？

【相同点】

1. 都是Java中的关键字。

2. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段，因为它们都是需要依赖对象。

3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在。

【不同点】

1. this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用。

2. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性。

3. 在构造方法中：this(...)用于调用本类构造方法，super(...)用于调用父类构造方法，两种调用不能同时在构造方法中出现。

4. 构造方法中一定会存在super(...)的调用，用户没有写编译器也会增加（有子类存在的情况下），但是this(...)用户不写则没有。

对this（）与super（）不能同时出现在构造方法中的最简单解释：假设我们现在有一个父类和一个子类，我们想要在子类的构造方法中调用this（），首先就得调用super（），把super（）放在第一行，而this（）也需要放在第一行，因此就会冲突！换种情况，先调用super（）的话，就不满足，this（）在第一行了，因此又冲突了！由上可知：super（）和this（）不能同时出现在构造方法中。

再谈初始化

还记得我们之前学过的代码块吗？我们简单回顾一下重要的代码块：实例代码块和静态代码块。在没有继承关系时的执行顺序是：静态代码块执行 ——>实例代码块执行——>构造方法执行 。

静态代码块先执行，并且只执行一次，在类加载阶段执行；当有对象创建时，才会执行实例代码块，实例代码块执行完成后，最后构造方法才执行。

当父类和子类同时存在时，该怎么执行呢？

1、父类静态代码块优先于子类静态代码块执行，且是最早执行 2、父类实例代码块和父类构造方法紧接着执行 3、子类的实例代码块和子类构造方法紧接着再执行 4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行。

下面我们就用代码来验证一下：

public class Test{
       public static void main(String[] args){
           Dog dog = new Dog();
       }
}

class Animol{
    public String name;
    public int age;
    public Animol(String name, int age){
         = name;
        this.age = age;
        System.out.println("父类构造方法");
    }
    {
        System.out.println("父类实例代码块");
    }
    static{
        System.out.println("父类静态代码块");
    }

}

class Dog  extends Animol{
    public String character;
    public Dog(){
        super("huahua",5);
        System.out.println("子类的构造方法");
    }
    {
        System.out.println("子类的实例代码块");
    }
    static{
        System.out.println("子类的静态代码块");
    }
}

输出结果：

和我们的结论是一样的。 

protected 关键字

在学习类和对象时，为了实现封装特性，Java中引入了访问限定符，主要限定：类或者类中成员能否在类外或者其他包中被访问。现在我们就来学习protected这个关键字，其实也就是学习不同包中的子类，这个理解就是有两个类，一个是子类，一个是父类，而这两个类在不同的包中。这就是不同包中的子类。

注意：在父类中被private修饰的成员变量或者方法只是不能被子类访问，但是继承还是没问题的。

继承方式 

在现实生活中，事物之间的关系是非常复杂，灵活多样。比如下面这样：

 但在Java中只支持以下几种继承方式：

一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了. 如果想从语法上进行限制继承, 就可以使用 final 关键 。

final 关键字

final关键可以用来修饰变量、成员方法以及类。类似我们在C语言中学习的const。

1. 修饰变量或字段，表示常量(即不能修改）。

2. 修饰类：表示此类不能被继承。

我们平时是用的 String 字符串类, 就是用 final 修饰的, 不能被继承。

3. 修饰方法：表示该方法不能被重写(后序介绍) 。

继承与组合

和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果。组合并没有涉及到特殊的语法 (诸如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段。 继承表示对象之间是is-a的关系，比如：狗是动物，猫是动物。组合表示对象之间是has-a的关系，比如：汽车和其轮胎、发动机、方向盘、车载系统等的关系就应该是组合，因为汽车是由这些部件组成的。汽车中有这些东西。

// 轮胎类
class Tire{
    // ...
}
// 发动机类
class Engine{
    // ...
}
// 车载系统类
class VehicleSystem{
    // ...
}
//汽车有轮胎，发动机，车载系统（组成）
class Car{
    private Tire tire; // 可以复用轮胎中的属性和方法
    private Engine engine; // 可以复用发动机中的属性和方法
    private VehicleSystem vs; // 可以复用车载系统中的属性和方法
    // ...
}
// 奔驰是汽车(继承)
class Benz extends Car{
    // 将汽车中包含的：轮胎、发送机、车载系统全部继承下来
}

组合和继承都可以实现代码复用，应该使用继承还是组合，需要根据应用场景来选择，一般建议：能用组合尽量用组合。

好啦！本期Java继承篇的内容就已经学习完了。下一期我们再一起学习吧！