一. 继承

在Java中，可以将一个类的属性和方法继承到另一个类。我们将“继承概念”分为两个类别：

  • 子类（子类）：继承自另一个类的类
  • 超类（父类）：被继承的类

要从一个类继承，可以使用关键字 extends

1. 示例1，子类 继承了 超类 Car 的属性和方法：Vehicle

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Vehicle {
  protected String brand = "天使降临"; // 同一包中的其他类：可以访问 protected 成员
  public void honk() {
    System.out.println("一束刺眼的光");  
  }
}

class Car extends Vehicle { // 子类 car 继承了父类 Vehicle
  private String modelName = "迪迦";  
  public static void main(String[] args) {
    Car myFastCar = new Car();  // 创建一个Car对象
    myFastCar.honk();  // 调用 honk 方法
    System.out.println(myFastCar.brand + " " + myFastCar.modelName);  
  }
}

输出结果

1
2
一束刺眼的光
天使降临 迪迦

2. 疑问

  1. 关于protected修饰符

在Vehicle类中，brand属性被设置为protected访问修饰符。如果它被设置为private，则Car类将无法访问它。

为什么会这样？

  • protected 使得类中的成员变量（如brand）可以被该类本身以及所有继承该类的子类访问。所以，在 Car 类中，可以直接访问 Vehicle 类中的 brand 属性。
  • 如果 brand 属性被设置为 private，它就只能在 Vehicle 类内部访问，子类 Car 无法直接访问。这是因为 private 限制了属性的访问范围，仅限于定义该属性的类内部。
  1. 何时以及为什么使用“继承”？
  • 继承 提供了代码重用的好处。当你创建一个新类时，可以重用已有类的属性和方法，而不需要从头开始编写。这有助于提高开发效率和代码的可维护性。
  • 通过继承，可以创建一个子类，该子类不仅拥有父类的属性和方法，还可以根据需要进行扩展和修改。

3. 如果你尝试访问一个被 final 修饰的类，Java 会生成错误

示例2：结合上述 示例 1 

1
2
3
4
5
6
7
final class Vehicle { 
  ...
}

class Car extends Vehicle { // 编译错误，无法继承自final类
  ...
}

我们把上述例子 Vehicle 设置为 final

当car 继承 Vehicle 的时候就会出现 编译错误：无法继承自final类

二. 多态性

Java 多态

多态意味着“多种形式”，它发生在多个类通过继承关系相互关联时。

继承让我们能够从另一个类继承属性和方法。多态利用这些方法来执行不同的任务。这允许我们以不同的方式执行相同的操作。

1. 示例：创建 Pig 和 Dog 类的对象，并通过这些对象调用 animalSound() 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class Animal {  // 定义一个名为 Animal 的类
  public void animalSound() {  // 定义一个方法 animalSound，表示动物发出声音
    System.out.println("这只动物发出声音");  // 输出：这只动物发出声音
  }
}

class Pig extends Animal {  // 定义一个继承自 Animal 类的 Pig 类
  public void animalSound() {  // 重写 animalSound 方法，表示猪的叫声
    System.out.println("猪说：wee wee");  // 输出：“猪说：wee wee”（）
  }
}

class Dog extends Animal {  // 定义一个继承自 Animal 类的 Dog 类
  public void animalSound() {  // 重写 animalSound 方法，表示狗的叫声
    System.out.println("狗说：bow wow");  // 输出：狗说：bow wow
  }
}

class Main {  // 定义主类 Main
  public static void main(String[] args) {  // 主方法，程序执行的入口
    Animal myAnimal = new Animal();  // 创建一个 Animal 类型的对象 myAnimal
    Animal myPig = new Pig();  // 创建一个 Pig 类型的对象 myPig，并将其赋值给 Animal 类型的变量
    Animal myDog = new Dog();  // 创建一个 Dog 类型的对象 myDog，并将其赋值给 Animal 类型的变量
    
    myAnimal.animalSound();  // 调用 myAnimal 对象的 animalSound 方法，输出：这只动物发出声音
    myPig.animalSound();  // 调用 myPig 对象的 animalSound 方法，输出：猪说：wee wee
    myDog.animalSound();  // 调用 myDog 对象的 animalSound 方法，输出：狗说：bow wow
  }
}

总结：

  • 这段代码演示了继承和方法重写的概念。Pig 和 Dog 类继承自 Animal 类，并重写了 animalSound 方法，以提供各自特有的实现。
  • 当创建 Pig 或 Dog 对象并调用 animalSound 方法时，分别会输出猪和狗的叫声，而不是 Animal 类中的默认声音。

为什么以及何时使用“继承”和“多态”？

答： 它有助于代码重用：在创建新类时，可以重用现有类的属性和方法。