继承与多态性全解：J750编程高级特性速成


参考资源链接：[泰瑞达J750设备编程基础教程](https://wenku.csdn.net/doc/6412b472be7fbd1778d3f9e1?spm=1055.2635.3001.10343)
# 1. Java高级特性概述

在Java编程语言中，高级特性是构建复杂应用和框架的基础。这些特性不仅仅是为了代码的简洁和优雅，更关键的是它们提供了强大的机制，以应对面向对象编程（OOP）中常见且复杂的场景。本章将概述这些高级特性，并为后续章节中关于继承、多态等深入话题的探讨打下基础。

## 1.1 Java高级特性的分类

Java的高级特性可以大致分为以下几类：

- **继承**：允许创建一个类（子类）继承另一个类（父类）的属性和方法，是代码复用和组织层级关系的关键特性。
- **多态**：同一个操作作用于不同的对象，可以有不同的解释和不同的执行结果。
- **封装**：隐藏对象的属性和实现细节，仅对外提供公共访问方式，是Java面向对象编程三大特性之一。
- **抽象**：通过抽象类和接口来定义抽象行为，用于模拟现实生活中的复杂系统。

这些特性共同作用，使得Java成为了一种功能全面、高度灵活的编程语言。在实际开发过程中，合理地运用这些高级特性，可以帮助开发者写出更加简洁、高效、可维护的代码。随着我们深入探讨每个特性，将逐渐展示它们是如何在现代Java应用中实现这一目标的。

# 2. 继承机制的深入探讨

## 2.1 继承的基本概念与用法

### 2.1.1 类的继承结构与好处

在面向对象编程（OOP）中，继承是一种创建新类的机制，它允许从现有的类派生出新的子类。这种机制提供了代码重用的能力，使我们能够定义一个通用的基类，并通过继承机制创建更加特定的子类。继承的一个关键优点是它帮助我们建立了一种分类的层次结构，允许我们通过增加新的属性和方法来扩展基类的功能。

例如，我们可以定义一个基类 `Vehicle`，然后派生出 `Car`、`Truck` 等子类。`Car` 和 `Truck` 继承了 `Vehicle` 的属性和方法，比如轮子数量、引擎类型等，同时也可以添加各自特有的属性和方法，如汽车品牌、载重量等。

### 2.1.2 super和this关键字的深入理解

在 Java 中，`this` 关键字用于引用当前对象的实例，而 `super` 关键字则用于引用父类的属性和方法。当子类和父类中存在同名的字段或方法时，`this` 和 `super` 就显得尤为重要。

class Vehicle {
    int passengers = 10;

    public Vehicle() {
        System.out.println("Vehicle's constructor");
    }
}

class Car extends Vehicle {
    int passengers = 5;

    public Car() {
        System.out.println("Car's constructor");
    }

    public void printCarInfo() {
        System.out.println("Number of passengers in car: " + passengers);
        System.out.println("Number of passengers in vehicle: " + super.passengers);
    }
}

public class TestSuper {
    public static void main(String[] args) {
        Car car = new Car();
        car.printCarInfo();
    }
}

在上面的代码中，`Car` 类重写了 `Vehicle` 类的 `passengers` 字段。使用 `super.passengers` 可以访问父类的 `passengers` 值，而 `this.passengers` 将访问 `Car` 类自己的 `passengers` 值。这种方式在构造器和方法中都非常有用。

## 2.2 继承中的构造方法和初始化顺序

### 2.2.1 子类和父类的构造方法调用顺序

在 Java 中，构造方法的调用遵循特定的顺序，这个顺序从基类开始，一直到最派生的子类结束。每个类在构造时都会先调用其父类的构造方法。如果没有显式地调用父类的构造器，编译器会默认调用父类的无参构造器。

class Parent {
    Parent() {
        System.out.println("Parent's constructor");
    }
}

class Child extends Parent {
    Child() {
        System.out.println("Child's constructor");
    }
}

public class TestInheritance {
    public static void main(String[] args) {
        Child child = new Child();
    }
}

上述代码的输出将是：

Parent's constructor
Child's constructor

### 2.2.2 使用构造块和静态初始化块进行初始化

在 Java 类中，除了构造方法外，还可以使用构造块和静态初始化块进行初始化操作。构造块是类中的代码块，每次创建类的新对象时都会执行。静态初始化块仅在类被加载到 Java 虚拟机时执行一次。

class InitializationOrder {
    static {
        System.out.println("Static initialization block");
    }

    {
        System.out.println("Instance initialization block");
    }

    InitializationOrder() {
        System.out.println("Constructor");
    }
}

public class TestInitialization {
    public static void main(String[] args) {
        InitializationOrder obj = new InitializationOrder();
    }
}

上述代码的输出将是：

Static initialization block
Instance initialization block
Constructor

注意，静态初始化块在构造块和构造器之前执行。

## 2.3 抽象类和接口的继承

### 2.3.1 抽象类与抽象方法的作用

在 Java 中，抽象类可以包含抽象方法，即没有具体实现的方法。抽象方法只有声明，没有方法体。抽象类可以用来表示一个不完整的类，用于被其子类继承，实现具体的方法逻辑。

abstract class AbstractClassExample {
    abstract void display(); // 抽象方法

    // 普通方法（非抽象方法）
    void print() {
        System.out.println("Hello World");
    }
}

class AbstractChildClass extends AbstractClassExample {
    void display() { // 实现抽象方法
        System.out.println("Display method implementation");
    }
}

public class TestAbstractClass {
    public static void main(String[] args) {
        AbstractChildClass obj = new AbstractChildClass();
        obj.display();
        obj.print();
    }
}

### 2.3.2 接口与多继承的实现方式

在 Java 中，接口是一组方法声明，也可以包含变量。接口不能直接实例化，但可以用来实现多继承，因为一个类可以实现多个接口。

interface Printable {
    void print();
}

interface Showable extends Printable {
    void show();
}

class TestInterface implements Showable {
    public void print() {
        System.out.println("Print functionality implemented");
    }

    public void show() {
        System.out.println("Show functionality implemented");
    }

    public static void main(String[] args) {
        TestInterface obj = new TestInterface();
        obj.print();
        obj.show();
    }
}

## 2.4 设计模式中的继承应用

### 2.4.1 模板方法模式与继承的关系

模板方法模式是一种行为设计模式，它定义了一个操作中算法的骨架，并将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

abstract class Game {
    abstract void initialize();
    abstract void startPlay();
    abstract void endPlay();

    // 模板方法
    public final void play() {
        initialize();
        startPlay();
        endPlay();
    }
}

class Cricket extends Game {
    void initialize() {
        System.out.println("Cricket Game Initialize");
    }

    void startPlay() {
        System.out.println("Cricket Game Start");
    }

    void endPlay() {
        System.out.println("Cricket Game End");
    }
}

public class TemplatePatternDemo {
    public static void main(Strin