---

前言

本文学习主要内容为继承，分为继承相关概念、继承的访问问题、子类的构造、super和this的区别、代码块的执行顺序讲解、继承的方式、final关键字、以及继承和组合。

---

1、继承

1.1继承的概念

继承：就是子类继承父类的属性和行为，使得子类对象可以直接具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为

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

继承主要解决的问题是：共性的抽取，实现代码复用。

1.2继承有什么好处，为何要继承

比如：狗和猫，它们都是一个动物。

用Java语言来进行描述，就会设计出：

class  Dog{
    String name;
    int age;
    float weiht;
    public void eat(){
        System.out.println(name + "在吃饭");
    }
    public void sleep(){
        System.out.println(name + "在睡觉");
    }
public void bark(){
        System.out.println(name + "汪");
    }
}
class  Cat{
    String name;
    int age;
    float weiht;
    public void eat(){
        System.out.println(name + "在吃饭");
    }
    public void sleep(){
        System.out.println(name + "在睡觉");
    }
    public void mew(){
     System.out.println(name + "喵喵喵~~~");
 }
}

通过以上代码可以看出，猫和狗的类中存在大量重复的方法和成员，这时要解决这些代码的复用，就用到了面向对象思想中提出的继承的概念，专门来进行共性的抽取，从而实现代码的复用。

解决

将猫和狗类中的重复数据放到一个新的类里面，当做父类/基类，而猫和狗作为子类/派生类即可。

那么如何用代码来实现呢，请往下继续看

1.3继承的语句

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

修饰符 class 子类 extends 父类 {
 // ...  
}

此时对1.2中猫和狗的类进行重新设计：

class Animal {//作为父类
    String name;
    int age;
    public void eat(){
        System.out.println(name + "在吃饭");
    }
    public void sleep(){
        System.out.println(name + "在睡觉");
    }

}

class  Dog extends Animal{//继承父类，拥有父类的属性
    /*String name;
    int age;
    float weiht;
    public void eat(){
        System.out.println(name + "在吃饭");
    }
    public void sleep(){
        System.out.println(name + "在睡觉");
    }*/

    public void bark(){
        System.out.println(name + "汪");
    }
}

class  Cat extends Animal{//继承父类
   /* String name;
    int age;
    float weiht;
    public void eat(){
        System.out.println(name + "在吃饭");
    }
    public void sleep(){
        System.out.println(name + "在睡觉");
    }*/
    public void mew(){
        System.out.println(name + "喵");
    }
}

class TestA{
    public static void main(String[] args) {
        Dog dog = new Dog();
        // dog类中并没有定义任何成员变量，name和age属性肯定是从父类Animal中继承下来的
        System.out.println(dog.name);
        System.out.println(dog.age);
        // dog访问的eat()和sleep()方法也是从Animal中继承下来的
        dog.eat();
        dog.sleep();

        /*Cat cat = new Cat();
        System.out.println(cat.name);
        System.out.println(cat.age);*/


    }
}

1. 子类会将父类中的成员变量或者成员方法继承到子类中了

2. 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了

1.4父类成员的访问

在继承体系中，子类将父类中的方法和字段继承下来了，那在子类中能否直接访问父类中继承下来的成员呢？这种要分为访问父类的成员或者方法两情况。

1.4.1 子类中访问父类的成员变量

1. 子类和父类不存在同名成员变量

public class Base {
 int a;
 int b;
 }
 public class Derived extends Base{
 int c;
 public void method(){
 a = 10;    // 访问从父类中继承下来的a
 b = 20;    // 访问从父类中继承下来的b
 c = 30;    // 访问子类自己的c
 }
 }

2. 子类和父类成员变量同名

public class Base {
    int a;
    int b;
    int c;
 }
 
 public class Derived extends Base{
    int a;              // 与父类中成员a同名，且类型相同
    char b;             // 与父类中成员b同名，但类型不同
 
    public void method(){
        a = 100;        // 访问父类继承的a，还是子类自己新增的a？  访问的是子类的
        b = 101;        // 访问父类继承的b，还是子类自己新增的b？访问的是子类的
        c = 102;        // 子类没有c，访问的肯定是从父类继承下来的c
        // d = 103;     // 编译失败，因为父类和子类都没有定义成员变量b
    }
        //记住优先原则，子类有的先访问子类的。    
 }

在子类方法中 或者 通过子类对象访问成员时：

        如果访问的成员变量子类中有，优先访问自己的成员变量。

        如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。

        如果访问的成员变量与父类中成员变量同名，则优先访问自己的。

成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

1.4.2 子类中访问父类的成员方法

1. 成员方法名字不同

访问父类成员方法，跟访问父类成员变量差不多。

 public class Base {
     public void methodA(){
         System.out.println("Base中的methodA()");
     }
 }
 
public class Derived extends Base{
    public void methodB(){
        System.out.println("Derived中的methodB()方法");
    }
    
    public void methodC(){
        methodB();         // 访问子类自己的methodB()
        methodA();         // 访问父类继承的methodA()
        // methodD();      // 编译失败，在整个继承体系中没有发现方法methodD()
    }
 }

总结：成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时 再到父类中找，如果父类中也没有则报错。

2. 成员方法名字相同

public class Base {
     public void methodA(){
         System.out.println("Base中的methodA()");
     }
 
     public void methodB(){
         System.out.println("Base中的methodB()");
     }
 }
 
public class Derived extends Base{
    public void methodA(int a) {
        System.out.println("Derived中的method(int)方法");
    }
 
    public void methodB(){
        System.out.println("Derived中的methodB()方法");
    }
 
    public void methodC(){
        methodA();      // 没有传参，访问父类中的methodA()
        methodA(20);    // 传递int参数，访问子类中的methodA(int)
        methodB();      // 直接访问，则永远访问到的都是子类中的methodB()，基类的无法访问到
    }
 }

总结：

通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到 则访问，否则编译报错。

通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用 方法适传递的参数选择合适的方法访问，如果没有则报错；

问题：如果子类中存在与父类中相同的成员时，那如何在子类中访问父类相同名称的成员呢？

要解决这个那么就要学习super的使用了。

1.5 super关键字

Java提供了super关键字，该关键字主要作用：在子类方法中访问父 类的成员。

限定条件是，只能在子类中访问父类。

class Animal {//作为父类
    String name;
    int age;
    public void eat(){
        System.out.println(name + "在吃饭");
    }
    public void sleep(){
        System.out.println(name + "在睡觉");
    }

    public void show(){
        System.out.println("父类重写");
    }
}

class  Dog extends Animal{//继承父类，拥有父类的属性

    //定义与父类相同名的成员变量
    String name; // 与父类中成员变量同名且类型相同
    char age; // 与父类中成员变量同名但类型不同
   public void men(){
        //对于同名的成员变量，直接访问的话，访问到的都是子类
        age = 'a'; // 等价于： this.age = 100  this是当前对象的引用
        name = "韦kun";

        //如果要访问父类的成员变量,则需要借助super
        //super是获取到子类对象中从基类继承下来的部分
        super.name = "kk";
        super.age = 100;

       // 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法
       show();//这是重写的方法，默认会访问子类的方法
       super.show();//这样才可以访问到父类的方法
       show(10);//重载访问子类
    }

    // 与父类中show()构成重载，重载就是函数名一样，但是参数不同。
    public void show(int a){
        System.out.println(a);
        System.out.println(a + "子类");
    }
    //重写父类方法，后续会讲到重写，重写其实就是父类方法名和参数一模一样才行。
    public void show(){
        System.out.println("子类重写");
    }
    public void bark(){
        System.out.println(name + "汪");
    }

}

在子类方法中，如果想要明确访问父类中成员时，借助super关键字即可。

1. 只能在非静态方法中使用（即不能在含有static修饰的方法中使用）

2. 在子类方法中，访问父类的成员变量和方法。

2.子类构造方法

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

2.1如何创建构造方法

这里先讲一下idea编译器如何快速创建类的构造方法

鼠标右键，弹出这个界面，然后选择Generate,

然后选择Constructor

如果要有成员变量则给该成员创建构造方法

如果要创建无参的构造方法则点击第一个就行了。

2.2创建构造方法

class Base{
    int a ;
    public Base() {
        System.out.println("父类创建构造方法");
    }

}

class Son extends Base{
    int a;
    public Son() {
        super();//这个如果不写，也会默认有一个，但是当父类构造方法有参数时候需要传参
        System.out.println("子类创建构造方法");

    }

}

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

输出

说明构造方法顺序是先父类再到子类。有父才有子。

子类对象中成员是有两部分组成的，基类继承下来的以及子类新增加的部分 。父子父子 肯定是先有父再有子，所以在构造子类对象时候 ，先要调用基类的构造方法，将从基类继承下来的成员构造完整 ，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整 。

总结

1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构 造方法

2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的 父类构造方法调用，否则编译失败。

3. 在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。

4. super(...)只能在子类构造方法中出现一次，并且不能和this同时出现

3.super和this

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

【相同点】

1. 都是Java中的关键字
2. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段
3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在

【不同点】

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

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

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

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

4.代码块初始化的执行顺序

4.1在没有继承关 系时的执行顺序

class Person {
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("构造方法执行");
    }

    {
        System.out.println("实例代码块执行");
    }

    static {
        System.out.println("静态代码块执行");
    }
}

public class DaiMaKuai {
    public static void main(String[] args) {
        Person person1 = new Person("456",10);
        System.out.println("============================");
        Person person2 = new Person("123",20);
    }
}

执行结果：

静态代码块执行
实例代码块执行
构造方法执行
============================
实例代码块执行
构造方法执行

1. 静态代码块先执行，并且只执行一次，在类加载阶段执行

2. 当有对象创建时，才会执行实例代码块，实例代码块执行完成后，最后构造方法执行

4.2 继承关系上的执行顺序

class Person {
    public String name;
    public int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("Person：构造方法执行");
    }
    {
        System.out.println("Person：实例代码块执行");
    }
    static {
        System.out.println("Person：静态代码块执行");
    }
}
class Student extends Person{
    public Student(String name,int age) {
        super(name,age);
        System.out.println("Student：构造方法执行");
    }
    {
        System.out.println("Student：实例代码块执行");
    }

    static {
        System.out.println("Student：静态代码块执行");
    }
}

执行结果：

Person：静态代码块执行
Student：静态代码块执行
Person：实例代码块执行
Person：构造方法执行
Student：实例代码块执行
Student：构造方法执行
===========================
 Person：实例代码块执行
Person：构造方法执行
Student：实例代码块执行
Student：构造方法执行

通过分析执行结果，得出以下结论：

1、父类静态代码块优先于子类静态代码块执行，且是最早执行

2、父类实例代码块和父类构造方法紧接着执行

3、子类的实例代码块和子类构造方法紧接着再执行

4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

5.继承方式

java中，继承方式分别有 

单继承

多层继承

不同类继承同一个类

注意：Java中不支持多继承。

但是即使如此, 我们并不希望类之间的继承层次太复杂. 一般我们不希望出现超过三层的继承关系. 如果继承层 次太多, 就需要考虑对代码进行重构了.

如果想从语法上进行限制继承, 就可以使用 final 关键字

6.final关键字

f inal关键可以用来修饰变量、成员方法以及类。

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

final int a = 10;
    a = 20;//背final修饰了那么就不能修改

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

 final public class Animal {
 ...
 }
 public class Bird extends Animal {//被final修饰不能进行继承
 ...
 }
 // 编译出错

 3.修饰方法：表示该方法不能被重写

class Base{
    final int a = 10;
    //a = 20;//背final修饰了那么就不能修改
    final public void show(){
        System.out.println("父类");
    }
    
}
class Kun extends Base{

    @Override
    public void show() {//被final修饰的方法不能进行重写
        super.show();
    }
}

 7.继承和组合

和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果。组合并没有涉及到特殊的语法 (诸如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段。

继承表示对象之间是is-a的关系，比如：狗是动物，猫是动物

组合表示对象之间是has-a的关系，比如：汽车

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