抽象类

飞翔科技·周一晨会：部门主管大翔在会上强调："我们的薪资系统必须标准化——正式员工、实习生、外包人员都要纳入统一结算框架。但是每种人的工资算法不一样，直接写一个 Employee 类又怕子类忘记重写结算逻辑。" 架构师白歌说："这正是抽象类的典型场景——提取共性，强制子类实现差异。"

什么是抽象类

抽象类（Abstract Class） 是一种不能被实例化的类，它的存在意义是作为父类模板，提取多个子类的共性字段和共性方法，同时将"不确定如何实现"的方法声明为抽象方法，强制每个子类提供自己的实现。

// 抽象类：提取员工共性，定义结算契约
public abstract class Employee {
    protected String name;
    protected String id;

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

    // 抽象方法：只有签名，没有方法体——子类必须实现
    public abstract double calculateSalary();

    // 具体方法：子类可直接继承使用
    public String getInfo() {
        return "姓名：" + name + "，工号：" + id;
    }
}

calculateSalary() 的签名被"定死"了，但具体怎么算，由子类说了算。编译器会检查每个子类是否实现了该方法。

核心语法

定义抽象类与抽象方法

语法元素写法说明
抽象类声明public abstract class ClassName { }abstract 修饰类，该类不能被 new 实例化
抽象方法声明public abstract ReturnType methodName(params);abstract 修饰方法，没有方法体（直接以分号结尾）
抽象类中的具体方法public ReturnType methodName(params) { ... }抽象类可以包含普通方法，子类直接继承
抽象类中的成员变量protected String name;可以有任意类型的成员变量
抽象类的构造方法public ClassName(params) { ... }可以有构造方法，供子类通过 super() 调用

抽象方法 vs 具体方法

public abstract class Animal {
    // 抽象方法：没有 { } 方法体，分号结尾
    public abstract void makeSound();

    // 具体方法：有完整方法体
    public void breathe() {
        System.out.println("动物呼吸中...");
    }
}
对比维度抽象方法具体方法
方法体 { }无，以 ; 结尾有
abstract 修饰必须有不能有
所在类必须在抽象类或接口中任意类均可
子类处理必须重写（除非子类也是抽象类）可选重写

深度原理分析

1. 为什么抽象类不能被实例化？

从 JVM 内存模型角度看，new 一个对象需要三步：

  1. 在堆上分配内存
  2. 调用 <init>（构造方法）初始化对象
  3. 将引用压入操作数栈

抽象类包含没有方法体的抽象方法。如果 JVM 允许 new 抽象类对象：

Employee e = new Employee("张三", "001");  // ❌ 假设编译通过
e.calculateSalary();  // JVM 去哪找方法体？invokevirtual 跳转到哪里？

JVM 的 invokevirtual 指令需要一个完整的方法入口地址。抽象方法在常量池中的 Methodref 指向的是一个"未完成"的方法——它在类的 method_info 表中标记了 ACC_ABSTRACT 标志，但 Code 属性为空。调用这样的方法将导致 JVM 崩溃。

因此，Java 语言规范（JLS 8.1.1.1）明确规定：抽象类不能被实例化。编译器在 new 语句处直接报错。

2. 抽象类为什么可以有构造方法？

public abstract class Employee {
    protected String name;
    protected String id;

    public Employee(String name, String id) {  // 构造方法
        this.name = name;
        this.id = id;
    }
}

public class FullTimeEmployee extends Employee {
    private double monthlySalary;

    public FullTimeEmployee(String name, String id, double monthlySalary) {
        super(name, id);  // 调用抽象类构造方法初始化 name 和 id
        this.monthlySalary = monthlySalary;
    }
}

抽象类的构造方法不是给自己用的，而是给子类调用的。子类通过 super() 链式调用，完成父类成员变量的初始化。

3. JVM 如何保证抽象方法被实现？

在类加载的验证阶段，JVM 会检查每一个非抽象子类是否实现了所有继承的抽象方法。如果发现遗漏：

Exception in thread "main" java.lang.Error: Unresolved compilation problem:
    The type SubClass must implement the inherited abstract method
    SuperClass.abstractMethod()

这个检查发生在 字节码验证 阶段（ClassLoader.defineClass() 中的 verify() 步骤），比运行时更早，因此是 100% 安全的。

完整示例：飞翔科技薪资结算系统

示例一：模板方法模式——员工薪资结算

架构师白歌设计了基于抽象类的模板方法模式，将薪资结算流程固化，差异部分交给子类实现。

// ============ Employee.java ============
/**
 * 员工抽象类——定义薪资结算模板
 */
public abstract class Employee {
    protected String name;
    protected String id;
    protected int workDays;  // 当月出勤天数

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

    /**
     * 模板方法：定义薪资结算的固定流程
     * final 修饰，防止子类篡改流程
     */
    public final void processSalary() {
        System.out.println("========== " + name + "（" + id + "）薪资结算 ==========");
        double baseSalary = calculateBaseSalary();      // 步骤1：计算基本工资（抽象方法，子类实现）
        double bonus = calculateBonus(baseSalary);      // 步骤2：计算奖金（钩子方法，子类可选重写）
        double deduction = calculateDeduction(baseSalary); // 步骤3：计算扣款（具体方法）
        double total = baseSalary + bonus - deduction;    // 步骤4：汇总
        printSalarySlip(baseSalary, bonus, deduction, total); // 步骤5：打印工资条（具体方法）
    }

    /** 抽象方法：计算基本工资——子类必须实现 */
    protected abstract double calculateBaseSalary();

    /** 钩子方法：计算奖金——默认无奖金，子类可选重写 */
    protected double calculateBonus(double baseSalary) {
        return 0;
    }

    /** 具体方法：计算五险一金扣款 */
    private double calculateDeduction(double baseSalary) {
        double insurance = baseSalary * 0.105;  // 10.5% 五险一金
        double tax = Math.max(0, (baseSalary - 5000) * 0.03);  // 超额累进税率简化版
        return insurance + tax;
    }

    /** 具体方法：打印工资条 */
    private void printSalarySlip(double base, double bonus, double deduction, double total) {
        System.out.println("基本工资：" + String.format("%.2f", base));
        System.out.println("奖金：" + String.format("%.2f", bonus));
        System.out.println("五险一金+个税：" + String.format("%.2f", deduction));
        System.out.println("实发工资：" + String.format("%.2f", total));
        System.out.println("========================================");
        System.out.println();
    }
}

// ============ FullTimeEmployee.java ============
/**
 * 正式员工：按月薪计算
 */
public class FullTimeEmployee extends Employee {
    private double monthlySalary;    // 月薪
    private double performanceScore; // 绩效分（0.8 ~ 1.5）

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

    @Override
    protected double calculateBaseSalary() {
        // 正式员工：月薪 × (出勤天数 / 21.75) × 绩效系数
        return monthlySalary * (workDays / 21.75) * performanceScore;
    }

    @Override
    protected double calculateBonus(double baseSalary) {
        // 正式员工有年终奖分摊：基本工资的 8.33%
        return baseSalary * 0.0833;
    }
}

// ============ Intern.java ============
/**
 * 实习生：按日薪计算
 */
public class Intern extends Employee {
    private double dailyRate;     // 日薪
    private double overtimeHours; // 加班小时数

    public Intern(String name, String id, int workDays,
                  double dailyRate, double overtimeHours) {
        super(name, id, workDays);
        this.dailyRate = dailyRate;
        this.overtimeHours = overtimeHours;
    }

    @Override
    protected double calculateBaseSalary() {
        // 实习生：日薪 × 出勤天数 + 加班费
        double overtimeRate = dailyRate / 8.0 * 1.5;  // 加班费率 1.5 倍
        return dailyRate * workDays + overtimeRate * overtimeHours;
    }

    // 实习生不重写 calculateBonus，沿用默认 0
}

// ============ OutsourcedEmployee.java ============
/**
 * 外包人员：按项目工时计费
 */
public class OutsourcedEmployee extends Employee {
    private double hourlyRate;   // 时薪
    private int projectHours;    // 项目工时

    public OutsourcedEmployee(String name, String id, int workDays,
                              double hourlyRate, int projectHours) {
        super(name, id, workDays);
        this.hourlyRate = hourlyRate;
        this.projectHours = projectHours;
    }

    @Override
    protected double calculateBaseSalary() {
        // 外包人员：时薪 × 项目工时
        return hourlyRate * projectHours;
    }

    @Override
    protected double calculateBonus(double baseSalary) {
        // 外包人员超额完成有绩效奖励
        if (projectHours > 160) {
            return (projectHours - 160) * hourlyRate * 0.2;
        }
        return 0;
    }
}

// ============ Main.java ============
public class Main {
    public static void main(String[] args) {
        // 多态：用抽象类引用指向不同子类对象
        Employee[] employees = new Employee[3];
        employees[0] = new FullTimeEmployee("大翔", "FX001", 22,
                25000, 1.2);
        employees[1] = new Intern("小崔", "FX101", 20,
                200, 12);
        employees[2] = new OutsourcedEmployee("外包张三", "WB001", 22,
                80, 180);

        for (Employee emp : employees) {
            emp.processSalary();  // 统一调用模板方法，多态分发
        }
    }
}

运行输出：

========== 大翔（FX001）薪资结算 ==========
基本工资：30344.83
奖金：2527.72
五险一金+个税：3946.55
实发工资：28926.00
========================================

========== 小崔（FX101）薪资结算 ==========
基本工资：4450.00
奖金：0.00
五险一金+个税：467.25
实发工资：3982.75
========================================

========== 外包张三（WB001）薪资结算 ==========
基本工资：14400.00
奖金：320.00
五险一金+个税：1794.00
实发工资：12926.00
========================================

示例二：未实现全部抽象方法的抽象子类

// 抽象父类
public abstract class Report {
    public abstract void generateHeader();
    public abstract void generateBody();
    public abstract void generateFooter();

    public void export() {
        generateHeader();
        generateBody();
        generateFooter();
        System.out.println("报表导出完成。");
    }
}

// 抽象子类：只实现了 generateHeader，其余仍是抽象
public abstract class AbstractExcelReport extends Report {
    @Override
    public void generateHeader() {
        System.out.println("【Excel 表头】生成中...");
    }
    // generateBody() 和 generateFooter() 仍然是抽象方法
    // 所以 AbstractExcelReport 也必须声明为 abstract
}

// 具体子类：补全所有抽象方法
public class SalaryExcelReport extends AbstractExcelReport {
    @Override
    public void generateBody() {
        System.out.println("【Excel 表体】薪资明细数据填充...");
    }

    @Override
    public void generateFooter() {
        System.out.println("【Excel 表尾】制表人：白歌，日期：2024-06-30");
    }
}

// 运行测试
public class Main {
    public static void main(String[] args) {
        SalaryExcelReport report = new SalaryExcelReport();
        report.export();
    }
}

运行输出：

【Excel 表头】生成中...
【Excel 表体】薪资明细数据填充...
【Excel 表尾】制表人：白歌，日期：2024-06-30
报表导出完成。

原理说明：AbstractExcelReport 没有实现全部抽象方法，它自身也是抽象类，不能被实例化。这形成了一个分级抽象的继承链——每级子类可以逐步落实部分抽象方法，直到最底层子类完成所有方法实现。

抽象类层次结构图

易错场景

反例一：试图 new 抽象类

// ❌ 错误：抽象类不能被实例化
public class Main {
    public static void main(String[] args) {
        Employee emp = new Employee("测试", "000", 20);
        // 编译错误：Cannot instantiate the type Employee
    }
}

编译错误：
Employee is abstract; cannot be instantiated

纠正：

// ✅ 正确：通过子类实例化
Employee emp = new FullTimeEmployee("测试", "000", 20, 15000, 1.0);
emp.processSalary();  // 多态调用，OK

反例二：抽象方法有方法体

// ❌ 错误：抽象方法不能有方法体
public abstract class Employee {
    public abstract double calculateSalary() {
        return 0;  // 编译错误！
    }
}

编译错误：
abstract methods cannot have a body

纠正：

// ✅ 正确：抽象方法以分号结尾
public abstract class Employee {
    public abstract double calculateSalary();
}

反例三：具体子类遗漏抽象方法

// ❌ 错误：FullTimeEmployee 继承了 Employee 但没有实现 calculateSalary()
public abstract class Employee {
    public abstract double calculateSalary();
}

public class FullTimeEmployee extends Employee {
    private double monthlySalary;

    public FullTimeEmployee(double monthlySalary) {
        super("default", "000", 22);  // 调用了父类构造
        this.monthlySalary = monthlySalary;
    }
    // 忘记实现 calculateSalary() —— 编译错误
}

编译错误：
The type FullTimeEmployee must implement the inherited abstract method
Employee.calculateSalary()

纠正：

// ✅ 正确：实现所有抽象方法
public class FullTimeEmployee extends Employee {
    private double monthlySalary;

    public FullTimeEmployee(double monthlySalary) {
        super("default", "000", 22);
        this.monthlySalary = monthlySalary;
    }

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

反例四：final 与 abstract 冲突

// ❌ 错误：final 方法不能被重写，abstract 方法必须被重写——矛盾
public abstract class Employee {
    public abstract final double calculateSalary();
    // 编译错误：illegal combination of modifiers: abstract and final
}

编译错误：
illegal combination of modifiers: abstract and final

原理：abstract 要求方法必须被子类重写，final 禁止方法被重写。两个修饰符语义互斥。

面试考点

Q1：抽象类可以有构造方法吗？为什么？

可以。 抽象类的构造方法不是给自己用的（因为它不能被 new），而是给子类调用的。子类通过 super() 链式调用父类构造方法，完成父类成员变量的初始化。这是继承体系中对象初始化的标准机制。

Q2：抽象类和普通类有什么区别？

对比维度抽象类普通类
abstract 修饰必须有无
实例化不能 new可以 new
抽象方法可以有不能有
构造方法可以有（供子类调用）可以有
被继承主要目的就是被继承可以被继承，但不是必须的

Q3：abstract 关键字不能和哪些关键字同时使用？

  • abstract + final：矛盾，抽象方法必须被重写，final 禁止重写
  • abstract + private：矛盾，抽象方法需要被子类重写，private 方法子类不可见
  • abstract + static：矛盾，抽象方法属于实例，static 方法属于类
  • abstract + synchronized：矛盾，synchronized 不是方法签名的组成部分
  • abstract + native：矛盾，抽象方法无方法体由子类实现，native 方法无方法体由本地代码实现

Q4：什么是模板方法模式（Template Method Pattern）？

模板方法模式是抽象类的经典应用：在抽象父类中定义一个 final 方法作为骨架算法，将算法中的可变步骤声明为抽象方法交给子类实现。父类控制流程，子类提供细节——好莱坞原则：Don't call us, we'll call you。上文薪酬结算的 processSalary() 即为典型实现。

Q5：抽象类中是否可以没有抽象方法？

可以。 一个类声明为 abstract 只代表它不能被实例化，并不要求必须包含抽象方法。例如 java.awt.event.MouseAdapter 就是一个全部方法都是空实现的抽象类，目的是让子类只重写关心的那一个方法。