Java抽象类的那些事儿，一看就懂

大家好，我是小欧！
在 Java 编程世界里，有一个非常重要的概念，那就是抽象类。对于初学者来说，抽象类可能有点儿抽象（哈哈，这不是废话嘛），但只要我们细细讲解，其实一点儿也不难理解。今天，我就带大家一起来揭开抽象类的神秘面纱。

什么是抽象类？

抽象类就像是一张设计图纸，它描绘了某种事物的大致模样，但不能直接拿来用。比如说，建筑师画了一张房子的蓝图，你不能直接住进蓝图里，只能根据蓝图去建造具体的房子。同样，抽象类就是这样一张“蓝图”，它定义了一些通用特性，但不能直接实例化（创建对象）。

抽象类和具体类的关系

想象一下，如果我们要定义一个“动物”类，不同的动物有不同的行为，比如狗会叫（bark），猫会喵喵叫（meow）。我们可以创建一个抽象的动物类，然后让具体的动物类去继承它，并实现它们各自的行为。

abstract class Animal {
    abstract void makeSound(); // 抽象方法，没有方法体
    void sleep() {
        System.out.println("Zzz...");
    }
}

在这个例子中，Animal 是一个抽象类，其中 makeSound 是一个抽象方法，而 sleep 是一个具体方法。抽象方法就像是一个待完成的任务，具体方法则是已经完成的任务。

继承抽象类

继承抽象类时，我们必须实现所有的抽象方法。来看一个具体的例子：

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Woof");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Meow");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();
        
        dog.makeSound(); // 输出: Woof
        cat.makeSound(); // 输出: Meow
        dog.sleep(); // 输出: Zzz...
    }
}

在这个例子中，我们创建了 Dog 和 Cat 类，它们都继承自 Animal 并实现了 makeSound 方法。运行 main 方法后，我们会看到各自不同的叫声，同时它们都可以调用 sleep 方法。

为什么要使用抽象类？

使用抽象类就像是制定了一个规则，所有遵循这个规则的具体实现都必须达到一定的标准。这种方式有很多好处：

1. 代码复用：抽象类可以定义通用行为，子类可以直接继承这些行为而不必重复代码。就像一家连锁店，每个分店的装修风格和服务标准都是一样的。
2. 定义标准：通过抽象方法，抽象类可以强制子类实现特定的行为，确保代码的一致性。就像是公司规定每个员工上班都必须穿工装。
3. 灵活性：抽象类可以包含具体方法和抽象方法，既提供了实现也提供了规范。这就好比是一本带有示例的操作手册。

实际案例一：支付系统

假设我们要开发一个支付系统，不同的支付方式（比如信用卡、PayPal）有不同的支付逻辑。我们可以使用抽象类来实现这个功能。

定义抽象类

首先，我们定义一个抽象类 Payment，它包含支付金额和一个抽象方法 makePayment。

abstract class Payment {
    double amount;

    Payment(double amount) {
        this.amount = amount;
    }

    abstract void makePayment(); // 抽象方法

    void printReceipt() {
        System.out.println("Receipt: Payment of " + amount + " processed.");
    }
}

实现具体类

接下来，我们实现具体的支付方式类：信用卡支付和 PayPal 支付。

class CreditCardPayment extends Payment {
    CreditCardPayment(double amount) {
        super(amount);
    }

    @Override
    void makePayment() {
        System.out.println("Processing credit card payment of " + amount);
    }
}

class PayPalPayment extends Payment {
    PayPalPayment(double amount) {
        super(amount);
    }

    @Override
    void makePayment() {
        System.out.println("Processing PayPal payment of " + amount);
    }
}

测试支付系统

现在我们可以创建一些支付对象，并测试我们的支付系统了。

public class PaymentSystem {
    public static void main(String[] args) {
        Payment creditCard = new CreditCardPayment(100.0);
        Payment payPal = new PayPalPayment(200.0);

        creditCard.makePayment();
        creditCard.printReceipt(); // 输出: Receipt: Payment of 100.0 processed.
        
        payPal.makePayment();
        payPal.printReceipt(); // 输出: Receipt: Payment of 200.0 processed.
    }
}

在这个案例中，Payment 是一个抽象类，定义了支付金额和打印收据的方法。具体的支付方式（CreditCardPayment 和 PayPalPayment）继承了 Payment 类，并实现了具体的支付逻辑。

实际案例二：员工管理系统

假设我们在开发一个员工管理系统，公司有两类员工：全职员工（FullTimeEmployee）和兼职员工（PartTimeEmployee）。全职员工有固定工资，而兼职员工按小时计薪。我们可以使用抽象类来定义一个通用的员工类，然后让具体的员工类型去继承并实现各自的薪资计算方法。

定义抽象类

首先，我们定义一个抽象类 Employee，它包含员工的基本信息和一个抽象方法 calculateSalary，用于计算薪资。

abstract class Employee {
    String name;
    int id;

    Employee(String name, int id) {
        this.name = name;
        this.id = id;
    }

    // 抽象方法：计算薪资
    abstract double calculateSalary();

    // 打印员工信息
    void printEmployeeDetails() {
        System.out.println("Employee ID: " + id + ", Name: " + name);
    }
}

实现具体类

接下来，我们实现全职员工和兼职员工的具体类，分别继承 Employee 并实现 calculateSalary 方法。

class FullTimeEmployee extends Employee {
    double monthlySalary;

    FullTimeEmployee(String name, int id, double monthlySalary) {
        super(name, id);
        this.monthlySalary = monthlySalary;
    }

    @Override
    double calculateSalary() {
        return monthlySalary;
    }
}

class PartTimeEmployee extends Employee {
    double hourlyRate;
    int hoursWorked;

    PartTimeEmployee(String name, int id, double hourlyRate, int hoursWorked) {
        super(name, id);
        this.hourlyRate = hourlyRate;
        this.hoursWorked = hoursWorked;
    }

    @Override
    double calculateSalary() {
        return hourlyRate * hoursWorked;
    }
}

测试员工管理系统

现在我们可以创建一些员工对象，并测试我们的员工管理系统了。

public class EmployeeManagementSystem {
    public static void main(String[] args) {
        Employee fullTimeEmployee = new FullTimeEmployee("Alice", 101, 5000.0);
        Employee partTimeEmployee = new PartTimeEmployee("Bob", 102, 20.0, 120);

        fullTimeEmployee.printEmployeeDetails();
        System.out.println("Salary: " + fullTimeEmployee.calculateSalary());
        // 输出:
        // Employee ID: 101, Name: Alice
        // Salary: 5000.0

        partTimeEmployee.printEmployeeDetails();
        System.out.println("Salary: " + partTimeEmployee.calculateSalary());
        // 输出:
        // Employee ID: 102, Name: Bob
        // Salary: 2400.0
    }
}

在这个例子中，我们定义了一个 Employee 抽象类，包含员工的基本信息和一个抽象的薪资计算方法。然后，我们创建了两个具体类：FullTimeEmployee 和 PartTimeEmployee，分别实现了 calculateSalary 方法。最后，我们创建了具体的员工对象，并调用他们的方法，展示了不同类型员工的薪资计算方式。

抽象类 vs 接口

很多初学者会疑惑，抽象类和接口有什么区别？简单来说：

• 抽象类：可以包含具体方法和抽象方法，适用于有一些通用行为的情况。抽象类就像是一种蓝图，指导具体实现。
• 接口：只能包含抽象方法（Java 8 以后可以有默认方法和静态方法），适用于定义行为规范。接口更像是一个合同，规定了必须遵守的行为标准。

一般情况下，如果你想要定义一些共同的行为，并且允许子类复用代码，可以选择抽象类

。如果你只是想要定义一些方法签名，并且允许多重继承，可以选择接口。

小结

通过今天的介绍和两个实际案例，相信大家对抽象类有了更深入的了解。抽象类在 Java 编程中是一个非常强大的工具，它不仅可以帮助我们更好地组织代码，还能提高代码的复用性和可维护性。希望这些例子能让大家在实际编程中更好地应用抽象类，写出更加优雅和高效的代码。
如果你还有任何疑问，欢迎在评论区留言，关注我一起讨论。Happy coding!