抽象类案例

wen java案例 2026-08-03 240

本文目录导读：

抽象类案例

案例1：图形类（入门级）
案例2：支付系统（实用级）
案例3：员工管理系统（进阶级）
案例4：数据处理器（设计模式级）
抽象类设计要点总结

我将为您提供多个抽象类的实际案例,从简单到复杂，帮助您理解抽象类的使用场景和设计思路。

案例1：图形类（入门级）

// 抽象类 - 图形
abstract class Shape {
    protected String color;
    public Shape(String color) {
        this.color = color;
    }
    // 抽象方法 - 子类必须实现
    public abstract double getArea();
    public abstract double getPerimeter();
    // 具体方法 - 子类可以直接使用
    public void display() {
        System.out.println("颜色: " + color);
        System.out.println("面积: " + getArea());
        System.out.println("周长: " + getPerimeter());
    }
}
// 子类 - 圆形
class Circle extends Shape {
    private double radius;
    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
    @Override
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}
// 子类 - 矩形
class Rectangle extends Shape {
    private double width;
    private double height;
    public Rectangle(String color, double width, double height) {
        super(color);
        this.width = width;
        this.height = height;
    }
    @Override
    public double getArea() {
        return width * height;
    }
    @Override
    public double getPerimeter() {
        return 2 * (width + height);
    }
}
// 测试类
public class ShapeTest {
    public static void main(String[] args) {
        Shape circle = new Circle("红色", 5.0);
        Shape rectangle = new Rectangle("蓝色", 4.0, 6.0);
        System.out.println("=== 圆形 ===");
        circle.display();
        System.out.println("\n=== 矩形 ===");
        rectangle.display();
    }
}

案例2：支付系统（实用级）

// 抽象类 - 支付
abstract class Payment {
    protected String merchantId;
    protected double amount;
    protected String orderId;
    public Payment(String merchantId, double amount, String orderId) {
        this.merchantId = merchantId;
        this.amount = amount;
        this.orderId = orderId;
    }
    // 抽象方法 - 各支付方式的不同实现
    public abstract boolean authenticate();
    public abstract boolean processPayment();
    public abstract String generateReceipt();
    // 模板方法模式 - 定义支付流程
    public final void executePayment() {
        System.out.println("=== 开始支付流程 ===");
        if (!authenticate()) {
            System.out.println("认证失败");
            return;
        }
        if (!processPayment()) {
            System.out.println("支付失败");
            return;
        }
        String receipt = generateReceipt();
        System.out.println("支付成功，收据: " + receipt);
        sendConfirmation(receipt);
    }
    // 具体方法 - 通用逻辑
    private void sendConfirmation(String receipt) {
        System.out.println("发送支付确认通知...");
        System.out.println("确认信息: " + receipt);
        System.out.println("=== 支付流程结束 ===");
    }
}
// 支付宝支付
class AlipayPayment extends Payment {
    private String alipayAccount;
    public AlipayPayment(double amount, String orderId, String alipayAccount) {
        super("ALIPAY_MERCHANT", amount, orderId);
        this.alipayAccount = alipayAccount;
    }
    @Override
    public boolean authenticate() {
        System.out.println("支付宝认证 - 账号: " + alipayAccount);
        return true;
    }
    @Override
    public boolean processPayment() {
        System.out.println("支付宝处理支付: " + amount + "元");
        return true;
    }
    @Override
    public String generateReceipt() {
        return "支付宝收据 - 订单" + orderId + " - " + amount + "元";
    }
}
// 微信支付
class WechatPayment extends Payment {
    private String wechatId;
    public WechatPayment(double amount, String orderId, String wechatId) {
        super("WECHAT_MERCHANT", amount, orderId);
        this.wechatId = wechatId;
    }
    @Override
    public boolean authenticate() {
        System.out.println("微信认证 - 微信ID: " + wechatId);
        return true;
    }
    @Override
    public boolean processPayment() {
        System.out.println("微信处理支付: " + amount + "元");
        return true;
    }
    @Override
    public String generateReceipt() {
        return "微信收据 - 订单" + orderId + " - " + amount + "元";
    }
}
// 银行卡支付
class BankCardPayment extends Payment {
    private String cardNumber;
    public BankCardPayment(double amount, String orderId, String cardNumber) {
        super("BANK_MERCHANT", amount, orderId);
        this.cardNumber = cardNumber;
    }
    @Override
    public boolean authenticate() {
        System.out.println("银行卡认证 - 卡号: " + cardNumber.substring(0, 4) + "****");
        return true;
    }
    @Override
    public boolean processPayment() {
        System.out.println("银行处理支付: " + amount + "元");
        return true;
    }
    @Override
    public String generateReceipt() {
        return "银行收据 - 订单" + orderId + " - " + amount + "元";
    }
}
// 测试类
public class PaymentTest {
    public static void main(String[] args) {
        System.out.println("=== 支付宝支付 ===");
        Payment alipay = new AlipayPayment(100.0, "ORDER001", "user@alipay.com");
        alipay.executePayment();
        System.out.println("\n=== 微信支付 ===");
        Payment wechat = new WechatPayment(200.0, "ORDER002", "wx_user123");
        wechat.executePayment();
        System.out.println("\n=== 银行卡支付 ===");
        Payment bankCard = new BankCardPayment(300.0, "ORDER003", "6222021234567890");
        bankCard.executePayment();
    }
}

案例3：员工管理系统（进阶级）

// 抽象类 - 员工
abstract class Employee {
    protected String name;
    protected int employeeId;
    protected double baseSalary;
    public Employee(String name, int employeeId, double baseSalary) {
        this.name = name;
        this.employeeId = employeeId;
        this.baseSalary = baseSalary;
    }
    // 抽象方法
    public abstract double calculateSalary();
    public abstract String getRole();
    // 具体方法
    public void displayInfo() {
        System.out.println("==========");
        System.out.println("标题: " + getRole());
        System.out.println("姓名: " + name);
        System.out.println("工号: " + employeeId);
        System.out.println("薪资: " + calculateSalary() + "元");
        performWork();
    }
    // 钩子方法 - 子类可选覆盖
    protected void performWork() {
        System.out.println("执行一般工作");
    }
}
// 永久员工
class PermanentEmployee extends Employee {
    private double bonus;
    private int yearsOfService;
    public PermanentEmployee(String name, int employeeId, double baseSalary, 
                            double bonus, int yearsOfService) {
        super(name, employeeId, baseSalary);
        this.bonus = bonus;
        this.yearsOfService = yearsOfService;
    }
    @Override
    public double calculateSalary() {
        // 基本工资 + 奖金 + 工龄工资（每年增加200）
        return baseSalary + bonus + (yearsOfService * 200);
    }
    @Override
    public String getRole() {
        return "永久员工";
    }
    @Override
    protected void performWork() {
        System.out.println("完成项目开发和团队协作");
    }
}
// 临时员工
class TemporaryEmployee extends Employee {
    private int workDays;
    private double dailyRate;
    public TemporaryEmployee(String name, int employeeId, double dailyRate, int workDays) {
        super(name, employeeId, 0);
        this.dailyRate = dailyRate;
        this.workDays = workDays;
    }
    @Override
    public double calculateSalary() {
        return dailyRate * workDays;
    }
    @Override
    public String getRole() {
        return "临时员工";
    }
    @Override
    protected void performWork() {
        System.out.println("完成临时性的工作任务");
    }
}
// 实习生
class InternEmployee extends Employee {
    private double stipend;
    public InternEmployee(String name, int employeeId, double stipend) {
        super(name, employeeId, 0);
        this.stipend = stipend;
    }
    @Override
    public double calculateSalary() {
        return stipend;
    }
    @Override
    public String getRole() {
        return "实习生";
    }
    @Override
    protected void performWork() {
        System.out.println("学习并协助项目工作");
    }
}
// 测试类
public class EmployeeTest {
    public static void main(String[] args) {
        // 多态 - 使用基类引用
        Employee[] employees = {
            new PermanentEmployee("张三", 1001, 8000, 2000, 3),
            new TemporaryEmployee("李四", 2001, 300, 20),
            new InternEmployee("王五", 3001, 1500)
        };
        System.out.println("=== 员工信息系统 ===\n");
        double totalSalary = 0;
        for (Employee emp : employees) {
            emp.displayInfo();
            totalSalary += emp.calculateSalary();
            System.out.println();
        }
        System.out.println("公司总薪资支出: " + totalSalary + "元");
    }
}

案例4：数据处理器（设计模式级）

// 抽象类 - 数据处理器（使用模板方法模式）
abstract class DataProcessor {
    // 模板方法 - 定义数据处理流程
    public final void process(String data) {
        Object validated = validate(data);
        Object cleaned = clean(validated);
        Object transformed = transform(cleaned);
        String result = save(transformed);
        notifyResult(result);
    }
    // 抽象方法
    protected abstract Object validate(String data);
    protected abstract Object clean(Object data);
    protected abstract Object transform(Object data);
    protected abstract String save(Object data);
    // 钩子方法
    protected void notifyResult(String result) {
        System.out.println("数据已保存: " + result);
    }
}
// 字符串处理器
class StringDataProcessor extends DataProcessor {
    @Override
    protected Object validate(String data) {
        System.out.println("验证字符串数据...");
        if (data == null || data.isEmpty()) {
            throw new IllegalArgumentException("字符串不能为空");
        }
        return data.trim();
    }
    @Override
    protected Object clean(Object data) {
        System.out.println("清理字符串数据...");
        String str = (String) data;
        return str.toLowerCase().replaceAll("[^a-zA-Z0-9\\s]", "");
    }
    @Override
    protected Object transform(Object data) {
        System.out.println("转换字符串数据...");
        String str = (String) data;
        return "transformed_" + str;
    }
    @Override
    protected String save(Object data) {
        System.out.println("保存到文本文件...");
        return "text_file_" + System.currentTimeMillis() + ".txt";
    }
}
// 数字处理器
class NumericDataProcessor extends DataProcessor {
    @Override
    protected Object validate(String data) {
        System.out.println("验证数字数据...");
        try {
            return Double.parseDouble(data);
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("无效的数字格式: " + data);
        }
    }
    @Override
    protected Object clean(Object data) {
        System.out.println("清理数字数据...");
        double num = (Double) data;
        return Math.round(num * 100.0) / 100.0; // 保留两位小数
    }
    @Override
    protected Object transform(Object data) {
        System.out.println("转换数字数据...");
        double num = (Double) data;
        return num * 100;
    }
    @Override
    protected String save(Object data) {
        System.out.println("保存到数据库...");
        return "db_record_" + data;
    }
    @Override
    protected void notifyResult(String result) {
        System.out.println("数字数据已存储: " + result);
    }
}
// JSON处理器
class JsonDataProcessor extends DataProcessor {
    @Override
    protected Object validate(String data) {
        System.out.println("验证JSON数据...");
        if (!data.startsWith("{")) {
            throw new IllegalArgumentException("无效的JSON格式");
        }
        return data;
    }
    @Override
    protected Object clean(Object data) {
        System.out.println("清理JSON数据...");
        String json = (String) data;
        // 模拟清理JSON格式
        return json.replaceAll("\\s+", "");
    }
    @Override
    protected Object transform(Object data) {
        System.out.println("转换JSON数据...");
        String json = (String) data;
        // 模拟添加时间戳
        return json.replace("}", ",\"timestamp\":\"" + System.currentTimeMillis() + "\"}");
    }
    @Override
    protected String save(Object data) {
        System.out.println("保存到MongoDB...");
        return "mongo_doc_" + data.hashCode();
    }
}
// 测试类
public class DataProcessorTest {
    public static void main(String[] args) {
        System.out.println("=== 字符串数据处理器 ===");
        DataProcessor stringProcessor = new StringDataProcessor();
        stringProcessor.process("  Hello World 123!  ");
        System.out.println("\n=== 数字数据处理器 ===");
        DataProcessor numericProcessor = new NumericDataProcessor();
        numericProcessor.process("12345.6789");
        System.out.println("\n=== JSON数据处理器 ===");
        DataProcessor jsonProcessor = new JsonDataProcessor();
        jsonProcessor.process("{\"name\":\"张三\", \"age\":30}");
    }
}

抽象类设计要点总结

最佳实践

模板方法模式: 在抽象类中定义算法骨架，子类实现具体步骤
钩子方法: 提供可选的扩展点，子类可以选择是否覆盖
代码复用: 将公共代码放在抽象类中，子类专注实现差异化逻辑

重要特性

// 抽象类可以有构造器（供子类调用）
// 抽象类可以有成员变量
// 抽象类可以有具体方法（非抽象方法）
// 抽象类可以有静态方法
// 抽象类不能实例化（不能new）
// 抽象方法必须被非抽象子类实现
// 抽象类可以没有抽象方法（作为基类使用）

与接口的选择建议

当有共同实现代码时使用抽象类
当存在"is-a"关系时使用抽象类
模板方法模式优先使用抽象类
表示能力强,需要继承时使用抽象类

这些案例展示了抽象类在实际项目中的常见应用场景,从基础的图形计算到复杂的企业级应用，每个案例都包含了完整的代码实现，您可以直接运行测试。

本文地址： https://www.bmjup.com/post/37461.html