抽象类在 Java 中的实际应用案例

抽象类在 Java 中的实际应用案例很多，以下是一些常见的例子：

1. 动物类示例

假设我们有一个 Animal 类，以及两个子类 Dog 和 Cat。Animal 类中定义了一个 eat() 方法，但这个方法的具体行为由子类决定。

public abstract class Animal {
    public void eat() {
        System.out.println("吃饭~");
    }
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("吃骨头~");
    }

    public void bark() {
        System.out.println("汪汪~");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("吃鱼~");
    }

    public void mimi() {
        System.out.println("喵喵~~");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.eat(); // 输出: 吃骨头~
        dog.bark(); // 输出: 汪汪~

        Animal cat = new Cat();
        cat.eat(); // 输出: 吃鱼~
        cat.mimi(); // 输出: 喵喵~~
    }
}

在这个例子中，Animal 类的 eat() 方法并没有实际意义，因为每种动物的饮食行为不同。因此，我们可以将 Animal 类定义为抽象类，只声明方法而不提供具体实现。

2. 形状类示例

假设我们要编写一个计算矩形、三角形和圆的面积与周长的程序。我们可以为这三个类抽象出一个父类 Shape，在父类里定义计算面积与周长的方法名，再将具体的计算公式在子类中实现。

public abstract class Shape {
    abstract void draw(); // 抽象方法

    void display() {
        System.out.println("This is a shape.");
    }

    double getArea();
    double getPerimeter();
}

class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    void draw() {
        System.out.println("Drawing a circle.");
    }

    @Override
    double getArea() {
        return Math.PI * radius * radius;
    }

    @Override
    double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}

class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    void draw() {
        System.out.println("Drawing a rectangle.");
    }

    @Override
    double getArea() {
        return width * height;
    }

    @Override
    double getPerimeter() {
        return 2 * (width + height);
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        circle.draw(); // 输出: Drawing a circle.
        System.out.println("Area: " + circle.getArea()); // 输出: Area: 78.53981633974483
        System.out.println("Perimeter: " + circle.getPerimeter()); // 输出: Perimeter: 31.41592653589793

        Shape rectangle = new Rectangle(4, 6);
        rectangle.draw(); // 输出: Drawing a rectangle.
        System.out.println("Area: " + rectangle.getArea()); // 输出: Area: 24.0
        System.out.println("Perimeter: " + rectangle.getPerimeter()); // 输出: Perimeter: 20.0
    }
}

在这个例子中，通过抽象类 Shape 定义了计算面积和周长的方法，具体的计算方法由子类 Circle 和 Rectangle 实现。

3. 车辆类示例

假设我们有一个 Vehicle 抽象类，包含一些通用的属性和方法，如 color 和 start() 方法，然后通过具体的子类 Car 和 Bike 来实现这些方法。

public abstract class Vehicle {
    protected String color;

    public Vehicle(String color) {
        this.color = color;
    }

    public abstract void start();
}

class Car extends Vehicle {
    public Car(String color) {
        super(color);
    }

    @Override
    public void start() {
        System.out.println("Car starting.");
    }
}

class Bike extends Vehicle {
    public Bike(String color) {
        super(color);
    }

    @Override
    public void start() {
        System.out.println("Bike starting.");
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle car = new Car("Red");
        car.start(); // 输出: Car starting.
        System.out.println(car.color); // 输出: Red

        Vehicle bike = new Bike("Blue");
        bike.start(); // 输出: Bike starting.
        System.out.println(bike.color); // 输出: Blue
    }
}

在这个例子中，Vehicle 类是一个抽象类，包含了一个抽象方法 start() 和一个具体方法 color。具体的实现由子类 Car 和 Bike 完成。

这些例子展示了抽象类在 Java 中的实际应用，通过抽象类可以有效地组织和管理代码，提高代码的可维护性和可扩展性。