继承的概述
假如我们想定义一个狗类和一个兔子类,它们都有吃东西和跑步的行为。只有两个类时,分别写一遍倒也不麻烦;但如果后来还要定义猫、马等更多动物,每个类都重复编写这些方法,代码就会越来越多。
这时就可以把动物共有的属性和行为抽取到一个 Animal 类中,再让狗、兔子等类继承它。需要某种动物特有的功能时,直接在对应的子类中补充即可。
Java 使用 extends 关键字建立类之间的继承关系,格式如下:
public class Student extends Person {
}这里的 Student 称为子类(也叫派生类),Person 称为父类(也叫基类、超类)。
用最开始的动物例子,可以写成:
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:
对应的代码关系是:
class Animal {
}
class Dog extends Animal {
}
class GuideDog extends Dog {
}那么 Animal 还有父类吗?有。除 Object 本身以外,Java 中的类最终都继承自 Object。例如我们直接写:
public class A {
}虽然没有写 extends,但 A 仍然继承自 Object,相当于省略了 extends Object。除了 Object 本身,Java 中的类最终都会继承它。
子类能继承父类的哪些内容?
父类中有成员变量、成员方法和构造方法,子类对它们的使用方式不太一样:
| 父类的内容 | 子类中的情况 |
|---|---|
| 成员变量 | 子类对象中也会有父类定义的那部分数据,但能不能直接访问还要看权限 |
| 成员方法 | 子类可以使用父类中允许访问的方法,有些方法还可以由子类重新编写 |
| 构造方法 | 不会被子类继承,但创建子类对象时仍要调用父类构造方法 |
这里最容易让人疑惑的是 private。例如,父类的 age 被 private 修饰,子类里不能直接写 age 来读取它。那创建子类对象后,父类中的 age 就不存在了吗?其实不是。
可以简单理解成:创建一个子类对象时,它既有从父类那边得到的数据,也有自己新增的数据,但并不会额外创建一个独立的父类对象。 父类的私有字段仍然在这份对象的数据里,只是子类不能直接访问。
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(),它会从哪里找到这个方法呢?
先看一个例子:
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:从直接父类的类型开始查找可访问的成员。
例如:
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():
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 是重写注解,可以让编译器帮忙检查:我们写的这个方法,到底有没有正确重写父类的方法。如果方法名或参数写错了,编译器就会提醒。以后写重写方法时,建议加上它。
方法重写还有几个基本要求:
- 方法名和参数要相同。 例如父类是
eat(),子类也写eat()。 - 访问权限不能缩小。 例如父类是
public,子类重写时也应是public。 - 返回值类型要符合要求。 先记住一般情况下保持一致;如果返回的是引用类型,允许返回更具体的子类型。
- 不是所有方法都能重写。
private、final方法不能被子类重写,static方法也不属于实例方法重写。
回到刚才的虚方法表:子类把 eat() 重写以后,调用子类对象的 eat(),就会执行“吃面条”的版本。不过父类的 eat() 并没有消失,使用 super.eat() 仍然可以执行“吃米饭”。
继承中构造方法的访问特点
父类的构造方法不能被子类继承,但创建子类对象时,会先调用父类的构造方法。
为什么呢?因为子类会用到父类中的成员,创建子类对象时,应该先把父类那部分数据初始化好,再继续执行子类自己的初始化。
通常情况下,如果子类构造方法里没有写 super(...),也没有通过 this(...) 调用本类其他构造方法,编译器就会默认加入一个 super(),调用父类的无参构造方法。
如果父类只有带参数的构造方法,没有可以调用的无参构造方法,那子类就需要自己写 super(参数),把参数传给父类。
例如:
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()。它并不表示又创建了一个父类对象。
| 用途 | this | super |
|---|---|---|
| 访问成员变量 | this.name:从当前类的成员开始查找 | super.name:从父类开始查找可访问的成员 |
| 调用成员方法 | this.eat():通过当前对象调用 | super.eat():调用父类中的实现 |
| 调用构造方法 | this(...):调用本类的其他构造方法 | super(...):调用父类的构造方法 |
this(...) 可以调用本类的其他构造方法,super(...) 可以调用父类的构造方法。在一个构造方法中,不能同时把这两种调用写在开头。静态方法里也不能使用 this、super 来访问实例成员。
回头看这些例子,继承的核心就是:父类负责放共用的内容,子类可以沿用,也可以增加自己的功能;父类的方法不适用时,还能在子类中重写。 this 和 super 则帮助我们区分当前类和父类中的成员。
聊两句
评论审核后显示有疑问、补充,或者想交流一下,都可以写在这里。
评论区将在滚动到这里时加载。