---

时间：2018-07-20 作者：魏文应

---

一、类的继承

什么是继承？

继承，是Java面向对象的三大特征之一。类可以继承其它类的特性。继承的格式如下：

class 类A extends 类B{
}

比如，下面有三个名为 Person、Student、Graduate 的类：

public class Person {
    public void eatFood(){
        System.out.println("正在吃东西！");
    }
}

public class Student extends Person {
    public void myPrintln(){
        System.out.println("Student print!");
        this.eatFood();
    }
}

public class Graduate extends Student{
    String name;
    public String getName(){
        return name;
    }
}

上面的代码中， Student 继承了 Person 类，这样，Student就 可以使用 Person 类内的方法和属性。同样，Graduate 继承了 Student 类，Graduate 既可以使用 Student的方法和属性，还可以使用 Person的方法和属性：

public class TestExtends {
    public static void main(String[] args){ 
        Student p1 = new Student();
        p1.eatFood();
        
        Graduate p2 = new Graduate();
        p2.eatFood();
        p2.myPrintln();
    }
}

private 属性和方法不可继承

private 属性的方法和属性，是类私有的，子类不可以使用。比如，下面给 eatFood 方法加上 private 修饰，则子类就不能继承这个方法了：

public class Person {
    private public void eatFood(){
        System.out.println("正在吃东西！");
    }
}

父类只有一个

一个类，只能继承一个父类（就好比一个人只有一个父亲一样）：

public class Student extends Person {
}

而下面这样是错误的，不能同时有两个父类：

public class Student extends Person Animal {
}

类的默认父类

每个类都有父类，就像每个人都有父母一样（除了最原始的那些类）。如果我们不显式地指明继承那个类，那么默认继承的是 Object 类，比如：

public class Student {
}

上这个 Student 类，没有指明继承哪个类，那么，默认就继承Object类：

public class Student extends Object{
}

二、方法的重写

方法的重写发生在子类中。

public class Person {
    public void eatFood(){
        System.out.println("一般人的吃饭方式！");
    }
}

public class Student extends Person {
    public void eatFood(){
        System.out.println("学生的吃饭方式！");
    }
}

public class TestExtends {
    public static void main(String[] args){
        Student p1 = new Student();
        p1.eatFood();
    }
}

上面代码中，Student 有自己的 eatFood() 方法，它将不再使用父类 Person 的 eatFood() 方法。即 p1.eatFood() 使用的是 Student 的 eatFood 方法。这就是 方法的重写。方法的 重写规则 如下：

• 要求子类方法的 返回值类型 方法名 （参数列表） 与父类方法 保持一致。
• 子类方法的修饰符 不能小于 父类方法的修饰符。
• 若父类方法抛出异常，那么子类方法抛出的异常类型 不能大于 父类方法抛出的异常。
• 子类和父类，必须同为 static类型 或者 非static类型。

三、super 关键字

下面的 Student 类继承了 Person 类：

public class Person {
    int id = 1;
}

public class Student extends Person {
    int id = 2;

    this.id = 3;
    super.id = 4;
}

this.id 指的是 Student 类的成员变量 int id = 2; ，super.id 指的是 Person 类的成员变量 int id = 1;。从这个示例可以看出，当子类和父类 有重名 的属性时，属性有super前缀时，说明是父类的属性。属性有this前缀时，说明是当前子类的属性 。如果是方法，也同样适用：

public class Person {
    public void show(){
        System.out.println("这是父类。");
    }
}

public class Student extends Person {
    public void show(){
        System.out.println("这是子类。");
    }

    public void test(){
        this.show();
        super.show();
    }
}

super 用于 构造器 ：

super 还可以用类的构造器中。

显式地调用 super 父类构造器

public class Person {   
    String name;
    
    public Person(String n){
        name = n;
        System.out.println("这是person构造器。");
    }
}

public class Student extends Person {
    public Student(){
        super("魏文应");
        System.out.println("这是Student构造器。");
    }
}

上面的 子类Student 中的 super("魏文应"); ，就是使用的就是 父类Person 的构造器 Person(String n)。

默认调用 super 父类构造器

如果 没有显式 地调用 super 构造器，那子类中的构造器会 默认添加super() ，比如：

public class Student extends Person {
    public Student(){
        System.out.println("这是Student构造器。");
    }
}

上面子类的构造器中，没有显式调用 父类 super 构造器。这时，编译器会自动添加 super() ：

public class Student extends Person {
    super();
    public Student(){
        System.out.println("这是Student构造器。");
    }
}

从上面可以看出，super() 必须写在子类构造器内部，而且要在类构造器内部代码的最前面，即类构造器内部的第一行代码。正因为 默认情况下，子类使用的是 super() ，所以这就意味着，父类必须有一个 空参构造器，比如父类 Person ：

public class Person {   
    String name;
    
    public Person(){
        name = n;
        System.out.println("这是person构造器。");
    }
}

为什么最好要有空参构造器？

我们知道，在类中，如果没有显式地定义构造器，编译器会自动添加一个空参构造器。比如下面：

public class Person {   
    String name;
}

通过编译器以后，会自动添加一个 Person() 构造器：

public class Person {   
    String name;
    
    public Person(){
        super();    //  没父类的类，默认继承Object类。
    }
}

如果我们显式地定义了一个构造器，那么，编译器将不再自动添加一个空参构造器。比如下面这个类，就没有 空参构造器：

public class Person {   
    String name;
    
    public Person(String n){
        name = n;
        System.out.println("这是person构造器。");
    }
}

但是，上面我们说过，子类默认情况下，会使用父类的 空参构造器 super()，如果父类没有空参构造器，这时就会报错。所以，在构造类时，最好有一个空参构造器，以便子类使用 。

为什么说 this() 和 super() 不能同时出现在同一个构造函数中？

public class Person {   
}

public class Student extends Person {
    public Student(){
        super();
        System.out.println("这是Student 空参构造器。");
    }

    public Student(String n){
        this();
        System.out.println("这是Student 带参构造器。");
    }
}

因为 super() 和 this() 都要写在构造器内的第一行，所以不能同时出现在一个构造器中。但是，你会发现，super 父类构造器一定会得到执行 。这也就意味着，每个类的构造器，都会先去执行父类的构造器，然后才开始执行本构造器的内容。

四、子类对象实例化的全过程

比如，我们有下面三个类，依次有继承关系：

public class Animal{
    int age;

    public Animal(){
        age = 12;
    }
}

public class Person extends Animal{
    String name;

    public Person(){
        name = "魏文应";
    }
}

public class Student extends Person {
    int classNum;

    public Student(){
        classNum = 0911;
    }
}

我们实例化一个 Student 对象：

Student s = new Stuent();

实例化的过程中，类的构造器会依次调用父类构造器，也就是下面的效果，Student() 构造器先调用执行Person()，然后才开始执行 classNum = 0911 代码。同样的Person()也是先执行Animal()，才执行 name = "魏文应";：

• 实例化过程

最终的效果是，依次将 age、name、classNum 这三个成员变量在内存堆中创建。也就是 Object() -> Animal() -> Person() -> Student() 这三个构造器依次得到执行。