Java 继承
Java 继承
一、引言
在 Java 面向对象编程技术中，继承是至关重要的概念，它如同一块基石，允许开发者创建分等级层次的类，大大提高了代码的复用性、可维护性以及开发效率。接下来，我们将深入探讨 Java 继承的各个方面。
二、继承的概念和特点
（一）概念
继承是面向对象软件技术里的一个核心概念。若类别 B “继承自” 类别 A，那么 B 就是 “A 的子类”，A 则被称为 “B 的父类别” 或 “B 的超类”。借助继承，子类能够拥有父类的各种属性和方法，无需重新编写相同代码。
Java 提供了类的继承机制，通过该机制，新建的子类可以使用或重写父类的成员方法，访问父类的成员变量。若 A 是 B 的父类，B 是 C 的父类，那么 C 也是 A 的子类。
（二）特点
- 单一继承：Java 中的继承为单一继承，即一个子类只能有一个父类，但一个父类可以有多个子类。
- 继承自 Object 类：所有的 Java 类都继承自
java.lang.Object类，所以Object是所有类的祖先类。除Object类外，所有类都必须有一个父类。若在定义类时未显式指定其父类，它默认继承自Object类。 - 全盘继承：子类一旦继承父类，就会继承父类所有开放的特征，无法选择性地继承。
- “is a” 关系：继承体现的是类与类之间 “is a” 的关系，即满足 A is a B 的关系就可以形成继承关系。
三、实现继承
在 Java 语言中，通过 extends 关键字声明一个类继承自另一个类。示例代码如下：
// 父类
class SuperClass {
// 父类的成员变量和方法
}
// 子类
class SubClass extends SuperClass {
// 子类的成员变量和方法
}
以宠物为例，宠物猫和宠物狗都是宠物，都有昵称、年龄等属性，都有吃东西、叫喊等行为。我们可以定义一个父类：宠物类，宠物猫和宠物狗类都继承宠物类。代码实现如下：
// 父类：宠物类
public class Pet {
private String name; // 昵称
private int age; // 年龄
// getter 和 setter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
// 吃东西
public void eat() {
System.out.println(this.getName() + "在吃东西");
}
// 叫喊
public void shout() {
System.out.println("宠物会叫");
}
}
// 宠物狗类
public class Dog extends Pet {
// 特有属性体重
private float weight;
// getter 和 setter
public float getWeight() {
return weight;
}
public void setWeight(float weight) {
this.weight = weight;
}
// 特有的方法 run
public void run() {
System.out.println("胖成了" + this.getWeight() + "斤的狗子在奔跑");
}
}
// 宠物猫类
public class Cat extends Pet {
public void sleep() {
System.out.println(this.getName() + "睡大觉zzz");
}
}
// 调用类的方法
public class Main {
public static void main(String[] args) {
// 实例化一个宠物狗
Dog dog = new Dog();
dog.setName("欢欢");
dog.setWeight(30f);
// 调用继承自父类的公有方法
dog.eat();
// 调用其特有方法
dog.run();
// 实例化一个宠物猫
Cat cat = new Cat();
cat.setName("豆豆");
// 调用继承自父类的公有方法
cat.eat();
// 调用其特有方法
cat.sleep();
}
}
运行结果：
欢欢在吃东西
胖成了30.0斤的狗子欢欢在奔跑
豆豆在吃东西
豆豆睡大觉zzz
四、方法重写
（一）概念
如果一个类从它的父类继承了一个方法，且该方法没有被标记为 final 或 static，就可以对这个方法进行重写。重写的好处是能够定义特定于子类类型的行为，即子类可以基于自身要求来实现父类的方法。
（二）实例
在上述父类 Pet 中有一个 shout 方法，由于小猫和小狗的叫声不同，我们可以在 Dog 类和 Cat 类中重写 shout 方法。
// Dog 类重写 shout 方法
class Dog extends Pet {
// 重写 shout 方法
public void shout() {
System.out.println(this.getName() + "汪汪汪地叫~");
}
}
// Cat 类重写 shout 方法
class Cat extends Pet {
@Override // 使用注解
public void shout() {
System.out.println(this.getName() + "喵喵喵地叫~");
}
}
// 调用重写方法
public class Main {
public static void main(String[] args) {
// 实例化一个宠物狗
Dog dog = new Dog();
dog.setName("欢欢");
// 调用重写方法
dog.shout();
// 实例化一个宠物猫
Cat cat = new Cat();
cat.setName("豆豆");
// 调用重写方法
cat.shout();
}
}
运行结果：
欢欢汪汪汪地叫~
豆豆喵喵喵地叫~
注意：在要重写的方法上面，可以选择使用 @Override 注解，让编译器帮助检查是否进行了正确的重写。若重写有误，编译器会提示错误。虽然这个注解不是必须的，但建议在日常编码中，在所有要重写的方法上都加上 @Override 注解，以避免因马虎造成的错误。
（三）方法重写规则
- 重写方法的参数列表应与原方法完全相同。
- 返回值类型应和原方法的返回值类型一样或者是它在父类定义时的子类型。
- 重写方法访问级别限制不能比原方法高。例如，若父类方法声明为公有的，那么子类中的重写方法不能是私有的或是保护的。具体限制级别参考访问修饰符。
- 只有被子类继承时，方法才能被重写。
- 方法定义为
final，将不能被重写。 - 一个方法被定义为
static，将使其不能被重写，但是可以重新声明。 - 一个方法不能被继承，那么也不能被重写。
- 和父类在一个包中的子类能够重写任何没有被声明为
private和final的父类方法。 - 和父类不在同一个包中的子类只能重写
non-final方法或被声明为public或protected的方法。 - 一个重写方法能够抛出任何运行时异常，不管被重写方法是否抛出异常。然而重写方法不应该抛出比被重写方法声明的更新更广泛的已检查异常，重写方法能够抛出比被重写方法更窄或更少的异常。
- 构造方法不能重写。
（四）方法重写和方法重载的区别
- 方法重写（Overriding）：子类重新定义了父类的方法。方法重写必须有相同的方法名、参数列表和返回类型，覆盖者访问修饰符的限定大于等于父类方法，且重写发生在具有继承关系的不同类中。
- 方法重载（Overloading）：发生在同一个类里面两个或者多个方法的方法名相同但是参数不同的情况，也可以发生在具有继承关系的不同类中。
五、访问修饰符
（一）作用
为了实现对类的封装和继承，Java 提供了访问控制机制。通过该机制，类的设计者可以掩盖变量和方法来维护类自身状态，同时将需要暴露的变量和方法提供给别的类进行访问和修改。
（二）种类
Java 一共提供了 4 种访问修饰符：
- private：私有的，只允许在本类中访问。
- protected：受保护的，允许在同一个类、同一个包以及不同包的子类中访问。
- 默认的：允许在同一个类、同一个包中访问。
- public：公共的，可以在任何地方访问。
访问修饰符在不同作用域的作用范围如下表所示：
| 访问控制修饰符 | 同一个类 | 同一个包 | 不同包的子类 | 不同包的非子类 |
|---|---|---|---|---|
| private（私有的） | ✓ | ✕ | ✕ | ✕ |
| default（默认的） | ✓ | ✓ | ✕ | ✕ |
| protected（受保护的） | ✓ | ✓ | ✓ | ✕ |
| public（公共的） | ✓ | ✓ | ✓ | ✓ |
六、super 关键字
super 是用在子类中的，目的是访问直接父类的变量或方法。使用时需注意：
super关键字只能调用父类的public以及protected成员。super关键字可以用在子类构造方法中调用父类构造方法。super关键字不能用于静态 (static) 方法中。
（一）调用父类构造方法
父类的构造方法既不能被继承，也不能被重写。可以使用 super 关键字在子类构造方法中调用父类的构造方法，语法为：
super(参数列表);
例如：
// 父类 Pet
class Pet {
public Pet(String name) {
System.out.println("宠物实例被创建了，宠物名字为" + name);
}
}
// 子类 Dog
class Dog extends Pet {
public Dog(String name) {
super(name);
System.out.println("小狗实例被创建了");
}
}
// 调用 Dog 有参构造方法进行实例化
public class Main {
public static void main(String[] args) {
new Dog("花花");
}
}
运行结果：
宠物实例被创建了，宠物名字为花花
小狗实例被创建了
（二）调用父类属性
子类中可以引用父类的成员变量，语法为：
super.成员变量名;
例如：
class Pet {
protected String birthday;
}
class Dog extends Pet {
public Dog() {
System.out.println("宠物生日：" + super.birthday);
}
}
（三）调用父类方法
有时候我们不想完全重写父类方法，可以使用 super 关键字调用父类方法，调用父类方法的语法为：
super.方法名(参数列表);
例如：
class Pet {
public void eat() {
System.out.println("宠物吃东西");
}
}
class Cat extends Pet {
public void eat() {
// 在 eat 方法中调用父类 eat 方法
super.eat();
System.out.println("小猫饭量很小");
}
}
class Test {
public static void main(String[] args) {
Cat cat = new Cat();
cat.eat();
}
}
运行结果：
宠物吃东西
小猫饭量很小
（四）super 与 this 的对比
- this 关键字：指向当前类对象的引用，使用场景为访问当前类的成员属性和成员方法、访问当前类的构造方法，且不能在静态方法中使用。
- super 关键字：指向父类对象的引用，使用场景为访问父类的成员属性和成员方法、访问父类的构造方法，同样不能在静态方法中使用。
需要注意的是，在构造方法调用时，super 和 this 关键字不能同时出现。
七、final 关键字
final 关键字可以作用于类、方法或变量，分别具有不同的含义。使用时，必须将其放在变量类型或者方法返回之前，建议将其放在访问修饰符和 static 关键字之后。
（一）final 作用于类
当 final 关键字用于类上面时，这个类不会被其他类继承。例如：
final class FinalClass {
public String name;
}
// 编译会报错
public class SubClass extends FinalClass {
}
（二）final 作用于方法
当父类中方法不希望被重写时，可以将该方法标记为 final。例如：
class SuperClass {
public final void finalMethod() {
System.out.println("我是final方法");
}
}
class SubClass extends SuperClass {
// 编译会报错
@Override
public void finalMethod() {
}
}
（三）final 作用于变量
对于实例变量，可以使用 final 修饰，其修饰的变量在初始化后就不能修改。例如：
class Cat {
public final String name = "小花";
}
// 编译会报错
public class Main {
public static void main(String[] args) {
Cat cat = new Cat();
cat.name = "小白";
}
}
八、小结
通过学习 Java 类的继承，我们可以发现它能够大大增加代码的复用性。Java 是单继承的语言，所有类的根类都是 Object，继承通过 extends 关键字实现。在使用过程中，要注意方法重写和方法重载的区别，避免混淆。类方法和 final 方法不能被重写。通过 super 关键字可以访问父类对象成员，而 final 关键字可以作用于类、方法和变量，对类、方法和变量进行限制。