深入解析Java编程中的抽象类

概念

在 Java 编程中，抽象类是一种不能被实例化的类，只能被继承，且其继承的子类必须实现抽象类中定义的抽象方法。抽象类通常被用来建模一种需求或者概念，以便多个子类可以对其进行具体的实现。

如何定义抽象类

使用 abstract 关键字来定义抽象类，抽象类中可以包含抽象方法、非抽象方法、成员变量和构造函数等成员。其中，抽象方法必须以分号结尾，而不能有方法体，因为抽象方法的具体实现是由其继承的子类来实现的。

public abstract class AbstractClass {
    public int num;

    public AbstractClass(int num) {
        this.num = num;
    }

    public abstract void doSomething();

    public void doSomethingElse() {
        System.out.println("do something else");
    }
}

如何继承抽象类

子类可以通过 extends 关键字来继承抽象类，如果子类不实现父类中的抽象方法，那么子类也必须定义为抽象类。

public class SubClass extends AbstractClass {
    public SubClass(int num) {
        super(num);
    }

    @Override
    public void doSomething() {
        System.out.println("do something");
    }
}

为什么需要抽象类

抽象类可以提供一种良好的程序设计方式，即针对一种概念或设计需求来进行建模，然后由多个具体的子类来进行实现。这样做不仅使程序具有更好的可维护性和扩展性，还可以降低代码耦合度和增强代码可读性。

示例1

假设我们需要编写一个费用计算程序，对于不同车型和不同里程数的租车费用进行计算，可以使用抽象类来建模这种需求。

public abstract class Car {
    private String name;
    private double basePrice;

    public Car(String name, double basePrice) {
        this.name = name;
        this.basePrice = basePrice;
    }

    public abstract double calculateCost(int mileage);

    public String getName() {
        return name;
    }

    public double getBasePrice() {
        return basePrice;
    }
}

public class Benz extends Car {
    public Benz() {
        super("Benz", 200);
    }

    @Override
    public double calculateCost(int mileage) {
        return super.getBasePrice() + mileage * 0.8;
    }
}

public class BMW extends Car {
    public BMW() {
        super("BMW", 250);
    }

    @Override
    public double calculateCost(int mileage) {
        return super.getBasePrice() + mileage * 0.9;
    }
}

通过定义抽象类 Car，可以建模出租车的抽象概念，并在子类 Benz 和 BMW 中对其进行具体的实现，从而实现了租车费用的计算。

示例2

另一个使用抽象类的例子是在游戏开发中，一个游戏中往往包含很多不同类型的游戏角色，而这些游戏角色往往具有共同的行为和属性，比如移动、攻击和防御等。可以使用抽象类来建模这种需求。

public abstract class GameCharacter {
    private String name;
    private int stength;
    private int defense;

    public GameCharacter(String name, int stength, int defense) {
        this.name = name;
        this.stength = stength;
        this.defense = defense;
    }

    public abstract void move();

    public abstract void attack(GameCharacter character);

    public abstract void defense();

    public String getName() {
        return name;
    }

    public int getStength() {
        return stength;
    }

    public int getDefense() {
        return defense;
    }
}

public class Warrior extends GameCharacter {
    public Warrior(String name) {
        super(name, 10, 5);
    }

    @Override
    public void move() {
        System.out.println(getName() + " is moving.");
    }

    @Override
    public void attack(GameCharacter character) {
        System.out.println(getName() + " is attacking " + character.getName());
    }

    @Override
    public void defense() {
        System.out.println(getName() + " is defending.");
    }
}

public class Mage extends GameCharacter {
    public Mage(String name) {
        super(name, 5, 10);
    }

    @Override
    public void move() {
        System.out.println(getName() + " is moving.");
    }

    @Override
    public void attack(GameCharacter character) {
        System.out.println(getName() + " is attacking " + character.getName());
    }

    @Override
    public void defense() {
        System.out.println(getName() + " is defending.");
    }
}

通过定义抽象类 GameCharacter，可以建模出游戏角色的抽象概念，并在子类 Warrior 和 Mage 中对其进行具体的实现，从而实现了游戏角色的行动。