Java继承、重写与多态性详解

一、引言 ?

在Java面向对象编程中，继承、重写和多态性是三大核心概念，它们为代码的复用、扩展和维护提供了强大的支持。理解这三个概念对于掌握Java编程至关重要。本文将深入探讨这三者的原理、用法和相互关系。

二、继承 ?

1. 什么是继承？

继承（Inheritance）是面向对象编程的基本机制，它允许一个类继承另一个类的属性和方法。通过继承，可以创建一个新的类，该类不仅拥有父类的功能，还可以添加新的功能。

2. 继承的语法

在Java中，使用 extends关键字来实现继承。

public class 父类 {
// 父类的属性和方法
}
public class 子类 extends 父类 {
// 子类的属性和方法
}

解释：

• public class 父类：定义一个父类。
• public class 子类 extends 父类：子类继承父类，拥有父类的属性和方法。

  3. 继承的特点

• 单继承：Java中，一个类只能继承一个直接父类。
• 层次继承：可以通过继承链形成类的层次结构。

  4. 继承的优势

• 代码复用：子类可以直接使用父类的方法和属性，减少重复代码。
• 可扩展性：子类可以扩展父类的功能，添加新的方法和属性。

  三、重写（覆盖）?

  1. 什么是重写？

  重写（Override）是指子类对父类的方法进行重新实现，以达到不同的功能表现。重写的方法必须与父类的方法具有相同的方法名、参数列表和返回类型。

  2. 重写的语法规则

• 方法名相同。
• 参数列表相同。
• 返回类型相同（Java 1.5后允许协变返回类型）。
• 访问权限不能更严格，可以更宽松。

  3. 示例代码

  父类：

  public class 动物 {
  public void 吃() {
  System.out.println("动物在吃东西");
  }
  }

  子类：

  public class 狗 extends 动物 {
  @Override
  public void 吃() {
  System.out.println("狗在吃骨头");
  }
  }

  解释：

• 在子类 狗中，重写了父类 动物的 吃()方法。
• 使用 @Override注解，方便编译器检查是否正确重写。
  

  4. 重写与重载的区别

  特点	重写	重载
  发生范围	子类与父类之间	同一类中
  方法名	相同	相同
  参数列表	相同	不同
  返回类型	相同或子类型	可不同
  访问修饰符	不能更严格，可更宽松	无要求

  四、多态性 ?

  1. 什么是多态性？

  多态性（Polymorphism）是指同一操作作用于不同的对象，可以产生不同的解释和执行结果。通俗来说，就是同一类型的对象，调用同一方法时，表现出不同的行为。

  2. 实现多态性的条件

• 继承：必须存在父类和子类的关系。
• 重写：子类重写父类的方法。
• 父类引用指向子类对象。

  3. 示例代码

  public class 测试多态 {
  public static void main(String[] args) {
  动物 animal = new 狗(); // 父类引用指向子类对象
  animal.吃(); // 调用的是狗的吃方法
  }
  }

  解释：

• 动物 animal = new 狗();：创建一个 狗对象，但引用类型是 动物。
• animal.吃();：调用方法时，实际运行的是 狗类的 吃()方法。

  4. 多态的优势

• 灵活性：代码更加通用，减少耦合。
• 可扩展性：添加新的子类无需修改现有代码。

  五、继承、重写与多态性的关系 ?

• 继承是实现重写和多态性的前提。
• 重写是为了实现多态性，子类通过重写父类的方法，实现不同的功能。
• 多态性依赖于继承和重写，通过父类引用指向子类对象，实现方法的动态绑定。

  六、工作流程图 ?️

  graph TD
  A[父类] -->|继承| B[子类]
  B -->|重写| C[子类方法]
  D[父类引用指向子类对象] --> E[多态性]
  E --> F[调用重写的方法]

  解释：

• A到B：子类继承父类。
• B到C：子类重写父类的方法。
• D到E：父类引用指向子类对象，实现多态性。
• E到F：调用重写的方法，执行子类的实现。

  七、示例：动物类的多态性 ?

  1. 定义父类 动物
  

  public class 动物 {
  public void 发声() {
  System.out.println("动物发出声音");
  }
  }

  2. 定义子类 狗和 猫
  

  public class 狗 extends 动物 {
  @Override
  public void 发声() {
  System.out.println("狗汪汪叫");
  }
  }
  public class 猫 extends 动物 {
  @Override
  public void 发声() {
  System.out.println("猫喵喵叫");
  }
  }

  3. 测试多态性

  public class 测试多态 {
  public static void main(String[] args) {
  动物 animal1 = new 狗();
  动物 animal2 = new 猫();
  animal1.发声(); // 输出：狗汪汪叫
  animal2.发声(); // 输出：猫喵喵叫
  }
  }

  解释：

• 创建了两个 动物类型的引用，分别指向 狗和 猫对象。
• 调用 发声()方法时，实际执行的是子类的实现。
  

  八、注意事项 ⚠️

  1. 重写时方法签名必须一致
  

  重写的方法必须与父类的方法具有相同的方法名、参数列表和返回类型。

  2. 不能重写父类的 private方法
  

  private方法对子类不可见，无法重写。

  3. 构造方法不能被继承或重写
  

  构造方法不参与继承，也不能被重写。

  九、实例解析 ?

  例子：银行账户系统

  1. 父类 账户
  

  public class 账户 {
  protected String 账号;
  protected double 余额;
  public 账户(String 账号, double 余额) {
  this.账号 = 账号;
  this.余额 = 余额;
  }
  public void 提现(double 金额) {
  if (余额 >= 金额) {
  余额 -= 金额;
  System.out.println("成功提现：" + 金额 + "元");
  } else {
  System.out.println("余额不足");
  }
  }
  }

  2. 子类 信用账户
  

  public class 信用账户 extends 账户 {
  private double 信用额度;
  public 信用账户(String 账号, double 余额, double 信用额度) {
  super(账号, 余额);
  this.信用额度 = 信用额度;
  }
  @Override
  public void 提现(double 金额) {
  double 可用额度 = 余额 + 信用额度;
  if (可用额度 >= 金额) {
  余额 -= 金额;
  System.out.println("成功提现：" + 金额 + "元，剩余额度：" + (可用额度 - 金额) + "元");
  } else {
  System.out.println("超出信用额度");
  }
  }
  }

  3. 测试代码

  public class 测试账户 {
  public static void main(String[] args) {
  账户 acc1 = new 账户("A001", 1000);
  账户 acc2 = new 信用账户("A002", 500, 1000);
  acc1.提现(1200); // 输出：余额不足
  acc2.提现(1200); // 输出：成功提现：1200元，剩余额度：300元
  }
  }

  解释：

• 账户类提供了基本的提现功能。
• 信用账户继承 账户，并重写了 提现()方法，加入了信用额度的概念。
• 测试中，acc1提现失败，acc2使用了信用额度，提现成功。
  

  十、继承与多态性的优势 ?

• 代码重用性：通过继承，子类无需重新编写父类已有的功能。
• 可维护性：修改父类代码，子类会自动继承变化，减少维护成本。
• 灵活性和扩展性：多态性使得程序更加灵活，易于扩展。

  十一、类与对象的关系图 ?️

  classDiagram
  父类 <|-- 子类1
  父类 <|-- 子类2
  父类 : +方法()
  子类1 : +方法()
  子类2 : +方法()

  解释：

• 父类是基类，提供通用的方法。
• 子类1和子类2继承父类，并可以重写方法。

  十二、结论 ?

  继承、重写和多态性是Java面向对象编程的核心概念，它们紧密联系，构成了Java强大的面向对象体系。掌握它们有助于编写出更高效、可维护、易扩展的代码。

  希望通过本文的讲解，您能深入理解Java的继承、重写与多态性，在实际编程中灵活运用，写出优秀的Java程序！?