继承的概述

假如我们想定义一个狗类和一个兔子类,它们都有吃东西和跑步的行为。只有两个类时,分别写一遍倒也不麻烦;但如果后来还要定义猫、马等更多动物,每个类都重复编写这些方法,代码就会越来越多。

这时就可以把动物共有的属性和行为抽取到一个 Animal 类中,再让狗、兔子等类继承它。需要某种动物特有的功能时,直接在对应的子类中补充即可。

Java 使用 extends 关键字建立类之间的继承关系,格式如下:

java
public class Student extends Person {
}

这里的 Student 称为子类(也叫派生类),Person 称为父类(也叫基类、超类)。

用最开始的动物例子,可以写成:

java
class Animal {
    public void eat() {
        System.out.println("吃东西");
    }

    public void run() {
        System.out.println("跑步");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println("汪汪叫");
    }
}

class Rabbit extends Animal {
}

public class Test1 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
        dog.run();
        dog.bark();

        Rabbit rabbit = new Rabbit();
        rabbit.eat();
    }
}

Dog 和 Rabbit 都没有重复编写 eat(),却可以直接调用它。Dog 还可以拥有自己的 bark() 方法。

继承主要有两个好处:一是把多个子类中重复的代码放到父类,提高复用性;二是允许子类在父类的基础上增加自己的功能。

不过,继承不能只看有没有重复代码,还要看两个类之间是否存在**“子类是一种父类”**的关系。狗是一种动物、兔子也是一种动物,因此适合考虑继承。

继承的特点

单继承与多层继承

Java 中的类只支持单继承:一个类只能有一个直接父类,不能同时 extends 两个类。不过,一个父类还可以继续继承其他类,因此 Java 支持多层继承。

例如,GuideDog(导盲犬)继承 Dog,而 Dog 继承 Animal:

箭头指向父类;对于 GuideDog,Dog 是直接父类,Animal 是间接父类。

对应的代码关系是:

java
class Animal {
}

class Dog extends Animal {
}

class GuideDog extends Dog {
}

那么 Animal 还有父类吗?有。除 Object 本身以外,Java 中的类最终都继承自 Object。例如我们直接写:

java
public class A {
}

虽然没有写 extends,但 A 仍然继承自 Object,相当于省略了 extends Object。除了 Object 本身,Java 中的类最终都会继承它。

子类能继承父类的哪些内容?

父类中有成员变量、成员方法和构造方法,子类对它们的使用方式不太一样:

父类的内容子类中的情况
成员变量子类对象中也会有父类定义的那部分数据,但能不能直接访问还要看权限
成员方法子类可以使用父类中允许访问的方法,有些方法还可以由子类重新编写
构造方法不会被子类继承,但创建子类对象时仍要调用父类构造方法

这里最容易让人疑惑的是 private。例如,父类的 age 被 private 修饰,子类里不能直接写 age 来读取它。那创建子类对象后,父类中的 age 就不存在了吗?其实不是。

可以简单理解成:创建一个子类对象时,它既有从父类那边得到的数据,也有自己新增的数据,但并不会额外创建一个独立的父类对象。 父类的私有字段仍然在这份对象的数据里,只是子类不能直接访问。

java
class Animal {
    private int age = 3;

    public int getAge() {
        return age;
    }
}

class Dog extends Animal {
    public void showAge() {
        // System.out.println(age); // 不能直接访问父类的 private 字段
        System.out.println(getAge()); // 通过父类提供的方法读取
    }
}

public class Test1 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.showAge(); // 3
    }
}

为什么 Dog 自己不能访问 age,却能调用 getAge() 呢?因为 getAge() 是在 Animal 里面写的,它当然能访问本类的私有变量;而 Dog 可以调用这个公开的方法,于是就间接读到了年龄。

private 方法也不能直接在子类中调用。至于 static 和 final,现在先记住它们与普通实例方法的区别:static 方法不参与下面讲的方法重写,final 方法可以被子类使用,但不允许重写。它们的细节暂时不展开。

成员方法是怎么找到的?

假设有三个类:C 继承 B,B 又继承 A。如果 C 没有写 eat(),却调用了 eat(),它会从哪里找到这个方法呢?

先看一个例子:

java
class A {
    public void eat() {
        System.out.println("A 的 eat");
    }
}

class B extends A {
    @Override
    public void eat() {
        System.out.println("B 的 eat");
    }
}

class C extends B {
}

public class Test1 {
    public static void main(String[] args) {
        C c = new C();
        c.eat(); // B 的 eat
    }
}

C 自己没写 eat(),但 B 有,所以调用 c.eat() 时,执行的是 B 中的方法。如果 B 也没有编写这个方法,就可以使用 A 中的版本。

那是不是每调用一次,都要从 C 往 B、A 一级一级重新翻找呢?可以先把 虚方法表 想成一份“方法清单”:Java 运行时可以借助这类信息,快速知道某个对象调用的方法应该执行哪个版本。

比如 A 有 eat(),B 没改它时,就沿用 A 的版本;B 重新写了 eat(),从 B 继承的 C 就会用 B 的版本。这里说的“重新写一个同名方法”,就是接下来要学的方法重写。

虚方法表先理解到这个程度就够了:它帮助找到应该调用的方法,不是把父类的方法代码一份份复制进子类对象里。

继承中访问成员的特点

成员变量:就近原则

访问成员变量时,可以先按“就近原则”理解:如果有同名的局部变量、子类成员变量和父类成员变量,直接写变量名会优先使用当前作用域中更近的那个。

  • name:先找当前可见的局部变量,再按成员查找规则寻找。
  • this.name:从当前对象所属类的成员开始查找。
  • super.name:从直接父类的类型开始查找可访问的成员。

例如:

java
class Fu {
    String name = "父类的name";
}

class Zi extends Fu {
    String name = "子类的name";

    public void show(String name) {
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

public class Test1 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.show("局部变量的name");
    }
}

输出:

纯文本
局部变量的name
子类的name
父类的name

这里虽然都叫 name,但其实是三个不同位置的变量。所以 name、this.name 和 super.name 打印出来的结果也不同。

成员方法:直接调用与 super 调用

成员方法也可以先按就近原则来理解:子类有自己编写的版本,就用子类的;如果想明确调用父类的版本,可以写 super.方法名()。下面用“吃米饭、吃面条”的例子看看区别。

方法重写

前面提到,子类可以使用父类的方法。但有时候父类的做法不适合子类,就需要在子类里把这个方法重新写一遍,这就是方法重写。

例如,父类 Fu 的 eat() 表示“吃米饭”,子类 Zi 想把这个行为改成“吃面条”,就可以在子类中重写 eat():

java
class Fu {
    void eat() {
        System.out.println("吃米饭");
    }
}

class Zi extends Fu {
    @Override
    void eat() {
        System.out.println("吃面条");
    }

    void show() {
        eat();       // 调用子类重写后的方法
        super.eat(); // 调用父类的方法
    }
}

public class Test1 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.show();
    }
}

输出:

纯文本
吃面条
吃米饭

@Override 是重写注解,可以让编译器帮忙检查:我们写的这个方法,到底有没有正确重写父类的方法。如果方法名或参数写错了,编译器就会提醒。以后写重写方法时,建议加上它。

方法重写还有几个基本要求:

  1. 方法名和参数要相同。 例如父类是 eat(),子类也写 eat()。
  2. 访问权限不能缩小。 例如父类是 public,子类重写时也应是 public。
  3. 返回值类型要符合要求。 先记住一般情况下保持一致;如果返回的是引用类型,允许返回更具体的子类型。
  4. 不是所有方法都能重写。 private、final 方法不能被子类重写,static 方法也不属于实例方法重写。

回到刚才的虚方法表:子类把 eat() 重写以后,调用子类对象的 eat(),就会执行“吃面条”的版本。不过父类的 eat() 并没有消失,使用 super.eat() 仍然可以执行“吃米饭”。

继承中构造方法的访问特点

父类的构造方法不能被子类继承,但创建子类对象时,会先调用父类的构造方法。

为什么呢?因为子类会用到父类中的成员,创建子类对象时,应该先把父类那部分数据初始化好,再继续执行子类自己的初始化。

通常情况下,如果子类构造方法里没有写 super(...),也没有通过 this(...) 调用本类其他构造方法,编译器就会默认加入一个 super(),调用父类的无参构造方法。

如果父类只有带参数的构造方法,没有可以调用的无参构造方法,那子类就需要自己写 super(参数),把参数传给父类。

例如:

java
class Fu {
    public Fu(String name) {
        System.out.println("父类构造方法:" + name);
    }
}

class Zi extends Fu {
    public Zi() {
        super("张三");
        System.out.println("子类构造方法");
    }
}

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

输出:

纯文本
父类构造方法:张三
子类构造方法

从输出可以看到,先打印的是“父类构造方法”,然后才是“子类构造方法”。创建一次 Zi 对象,就会经历一次这样的过程。

目前按照课程中的常见写法,直接把 super(...) 放在子类构造方法的开头即可。

this 与 super 的总结

前面在访问成员变量、重写方法和构造方法时,都用到了 this、super。它们看起来很像,但含义不同。

  • this:可以理解成“当前这个对象”,用它访问当前对象的成员,比如 this.name。
  • super:可以理解成“去父类那边找”,比如 super.name 或 super.eat()。它并不表示又创建了一个父类对象。
用途thissuper
访问成员变量this.name:从当前类的成员开始查找super.name:从父类开始查找可访问的成员
调用成员方法this.eat():通过当前对象调用super.eat():调用父类中的实现
调用构造方法this(...):调用本类的其他构造方法super(...):调用父类的构造方法

this(...) 可以调用本类的其他构造方法,super(...) 可以调用父类的构造方法。在一个构造方法中,不能同时把这两种调用写在开头。静态方法里也不能使用 this、super 来访问实例成员。

回头看这些例子,继承的核心就是:父类负责放共用的内容,子类可以沿用,也可以增加自己的功能;父类的方法不适用时,还能在子类中重写。 this 和 super 则帮助我们区分当前类和父类中的成员。

谢谢你读到这里。 ✧

聊两句

评论审核后显示

有疑问、补充,或者想交流一下,都可以写在这里。

评论区将在滚动到这里时加载。