抽象类是面向对象抽象、继承、模板复用的核心载体，用于抽取子类的公共代码、定义统一行为规范。不同于普通类，抽象类可定义抽象方法，强制子类实现个性化逻辑，有效解决代码冗余、子类行为不统一的问题，是模板模式、层级架构的常用实现方式。
场景1：抽取公共父类（面向对象·继承复用）
项目中多个子类存在大量重复属性和方法时，通过抽象类抽取通用代码，向上提炼共性，子类直接继承复用，无需重复编写，减少冗余代码，符合面向对象复用思想。常用于用户、订单、商品等多级实体体系。

public abstract class BaseEntity {
    // 公共通用属性
    private Long createTime;
    private Long updateTime;
    private Integer createUser;
    private Integer updateUser;

    // 公共通用方法
    public void initCreateInfo() {
        this.createTime = System.currentTimeMillis();
        this.updateTime = System.currentTimeMillis();
    }

    public void initUpdateInfo() {
        this.updateTime = System.currentTimeMillis();
    }

    // getter、setter
    public Long getCreateTime() { return createTime; }
    public void setCreateTime(Long createTime) { this.createTime = createTime; }
    public Long getUpdateTime() { return updateTime; }
    public void setUpdateTime(Long updateTime) { this.updateTime = updateTime; }
    public Integer getCreateUser() { return createUser; }
    public void setCreateUser(Integer createUser) { this.createUser = createUser; }
    public Integer getUpdateUser() { return updateUser; }
    public void setUpdateUser(Integer updateUser) { this.updateUser = updateUser; }
}

场景2：模板方法统一流程（面向对象·抽象规范）
利用抽象方法定义统一业务流程骨架，将固定流程写在抽象父类，差异化逻辑定义为抽象方法，强制子类实现。保证整体执行流程统一，同时支持子类个性化扩展，彻底解决子类实现混乱、流程不统一的问题。

public abstract class AbstractPayTemplate {
    // 统一支付模板：固定流程，子类不可重写
    public final void pay(Long orderId, double amount) {
        checkOrder(orderId);
        doPay(amount);
        recordLog(orderId);
    }

    // 通用校验逻辑
    public void checkOrder(Long orderId) {
        System.out.println("校验订单合法性：" + orderId);
    }

    // 子类必须实现的个性化支付逻辑
    public abstract void doPay(double amount);

    // 通用日志记录
    public void recordLog(Long orderId) {
        System.out.println("支付日志记录完成，订单号：" + orderId);
    }
}

// 支付宝支付子类
class AliPayTemplate extends AbstractPayTemplate {
    @Override
    public void doPay(double amount) {
        System.out.println("支付宝支付金额：" + amount + "元");
    }
}

// 微信支付子类
class WechatPayTemplate extends AbstractPayTemplate {
    @Override
    public void doPay(double amount) {
        System.out.println("微信支付金额：" + amount + "元");
    }
}

// 使用方式：统一模板流程，只关注差异化逻辑
AbstractPayTemplate pay = new AliPayTemplate();
pay.pay(10001L, 88.8);

场景3：规范子类行为（面向对象·约束特性）
当一组子类必须具备某些核心功能时，通过抽象类定义抽象方法，强制所有子类必须重写实现，从语法层面约束子类行为，避免子类缺失核心方法、业务实现不完整的问题，统一代码开发规范。

public abstract class AbstractFileHandler {
    // 定义文件处理统一规范，所有子类必须实现
    public abstract void upload(String filePath);
    public abstract void download(String fileKey);
    public abstract void delete(String fileKey);
}

// 本地文件处理
class LocalFileHandler extends AbstractFileHandler {
    @Override
    public void upload(String filePath) {
        System.out.println("本地上传文件：" + filePath);
    }

    @Override
    public void download(String fileKey) {
        System.out.println("本地下载文件：" + fileKey);
    }

    @Override
    public void delete(String fileKey) {
        System.out.println("本地删除文件：" + fileKey);
    }
}

// 阿里云OSS文件处理
class OssFileHandler extends AbstractFileHandler {
    @Override
    public void upload(String filePath) {
        System.out.println("OSS上传文件：" + filePath);
    }

    @Override
    public void download(String fileKey) {
        System.out.println("OSS下载文件：" + fileKey);
    }

    @Override
    public void delete(String fileKey) {
        System.out.println("OSS删除文件：" + fileKey);
    }
}

学习心得
抽象类是面向对象共性抽取、行为约束、模板复用的核心工具。核心思想就是：共性父类实现，个性子类实现。既能通过继承减少代码冗余，又能通过抽象方法强制规范子类行为，统一业务流程。熟练使用抽象类，可以让项目层级更清晰、代码扩展性更强，是搭建项目基础架构的关键技巧。