大家好，我是小欧！
在 Java 编程世界里，有一个非常重要的概念，那就是抽象类。对于初学者来说，抽象类可能有点儿抽象（哈哈，这不是废话嘛），但只要我们细细讲解，其实一点儿也不难理解。今天，我就带大家一起来揭开抽象类的神秘面纱。
什么是抽象类？
抽象类就像是一张设计图纸，它描绘了某种事物的大致模样，但不能直接拿来用。比如说，建筑师画了一张房子的蓝图，你不能直接住进蓝图里，只能根据蓝图去建造具体的房子。同样，抽象类就是这样一张“蓝图”，它定义了一些通用特性，但不能直接实例化（创建对象）。
抽象类和具体类的关系
想象一下，如果我们要定义一个“动物”类，不同的动物有不同的行为，比如狗会叫（bark），猫会喵喵叫（meow）。我们可以创建一个抽象的动物类，然后让具体的动物类去继承它，并实现它们各自的行为。
abstract class Animal {abstract void makeSound(); // 抽象方法，没有方法体void sleep() {System.out.println("Zzz...");}
}
在这个例子中，Animal 是一个抽象类，其中 makeSound 是一个抽象方法，而 sleep 是一个具体方法。抽象方法就像是一个待完成的任务，具体方法则是已经完成的任务。
继承抽象类
继承抽象类时，我们必须实现所有的抽象方法。来看一个具体的例子：
class Dog extends Animal {@Overridevoid makeSound() {System.out.println("Woof");}
}class Cat extends Animal {@Overridevoid makeSound() {System.out.println("Meow");}
}public class Main {public static void main(String[] args) {Animal dog = new Dog();Animal cat = new Cat();dog.makeSound(); // 输出: Woofcat.makeSound(); // 输出: Meowdog.sleep(); // 输出: Zzz...}
}
在这个例子中，我们创建了 Dog 和 Cat 类，它们都继承自 Animal 并实现了 makeSound 方法。运行 main 方法后，我们会看到各自不同的叫声，同时它们都可以调用 sleep 方法。
为什么要使用抽象类？
使用抽象类就像是制定了一个规则，所有遵循这个规则的具体实现都必须达到一定的标准。这种方式有很多好处：
- 代码复用：抽象类可以定义通用行为，子类可以直接继承这些行为而不必重复代码。就像一家连锁店，每个分店的装修风格和服务标准都是一样的。
- 定义标准：通过抽象方法，抽象类可以强制子类实现特定的行为，确保代码的一致性。就像是公司规定每个员工上班都必须穿工装。
- 灵活性：抽象类可以包含具体方法和抽象方法，既提供了实现也提供了规范。这就好比是一本带有示例的操作手册。
实际案例一：支付系统
假设我们要开发一个支付系统，不同的支付方式（比如信用卡、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);}@Overridevoid makePayment() {System.out.println("Processing credit card payment of " + amount);}
}class PayPalPayment extends Payment {PayPalPayment(double amount) {super(amount);}@Overridevoid 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;}@Overridedouble 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;}@Overridedouble 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.0partTimeEmployee.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!
