Java中的抽象类

1. 抽象类（Abstract Class）

定义：

• 使用 abstract 关键字修饰的类称为抽象类。
• 抽象类中可以包含抽象方法（只有声明，没有实现，没有方法体）。

语法结构：

修饰符 abstract class 类名 {
    // 成员变量
    // 构造器
    // 普通方法
    
    // 抽象方法（无方法体）
    修饰符 abstract 返回值类型 方法名(形参列表);
}

示例：

public abstract class Animal { //抽象类
    private String name;
    
    // 构造器
    public Animal(String name) {
        this.name = name;
    }
    
    // 普通方法
    public void sleep() {
        System.out.println(name + "正在睡觉");
    }
    
    // 抽象方法
    public abstract void makeSound();
}

---

2. 抽象类的核心特点

1. 不能实例化，不能创建对象：

   // Animal animal = new Animal(); // 编译错误！抽象类不能创建对象
   

2. 可包含抽象方法：
   • 有抽象方法的类必须是抽象类。
   • 抽象类不一定有抽象方法（可以全是具体方法）。
3. 子类继承规则：
   • 子类必须重写父类所有抽象方法，否则子类也必须声明为抽象类。
4. 完整成员支持：
   • 可包含成员变量、构造器、普通方法、静态方法等。

---

3. 抽象类的应用场景

核心价值：

• 强制子类实现统一行为：
  父类定义抽象方法，子类提供不同实现，支持多态。
• 代码复用与扩展：
  抽象类封装通用逻辑，子类只需实现差异化部分。

应用示例：

// 抽象父类：图形
public abstract class Shape {
    // 抽象方法：计算面积（子类必须实现）
    public abstract double calculateArea();
    
    // 普通方法：打印描述
    public void printDescription() {
        System.out.println("这是一个几何图形");
    }
}

// 子类1：圆形
public class Circle extends Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius; // 实现圆形面积计算
    }
}

// 子类2：矩形
public class Rectangle extends Shape {
    private double width;
    private double height;
    
    @Override
    public double calculateArea() {
        return width * height; // 实现矩形面积计算
    }
}

---

4. 模板方法设计模式

定义：

• 在抽象类中定义算法骨架（模板方法），将可变步骤延迟到子类实现。

优势：

• 提高复用性：封装不变流程，避免重复代码。
• 简化子类设计：子类只需关注特定步骤的实现。

实现步骤：

1. 定义抽象类，包含模板方法（用 final 修饰防止重写）。
2. 模板方法中调用抽象方法（可变步骤）。
3. 子类实现抽象方法，提供具体逻辑。

代码示例：

public abstract class DataProcessor {
    // 模板方法（final 防止子类重写）
    public final void process() {
        loadData();      // 步骤1：加载数据（共同逻辑）
        processData();   // 步骤2：处理数据（子类实现）
        saveResult();    // 步骤3：保存结果（共同逻辑）
    }
    
    // 共同方法
    private void loadData() {
        System.out.println("加载数据...");
    }
    
    private void saveResult() {
        System.out.println("保存结果...");
    }
    
    // 抽象方法（子类实现）
    protected abstract void processData();
}

// 子类：文件处理器
public class FileProcessor extends DataProcessor {
    @Override
    protected void processData() {
        System.out.println("处理文件数据...");
    }
}

// 子类：数据库处理器
public class DatabaseProcessor extends DataProcessor {
    @Override
    protected void processData() {
        System.out.println("处理数据库数据...");
    }
}

使用示例：

DataProcessor processor = new FileProcessor();
processor.process(); 
// 输出：
// 加载数据...
// 处理文件数据...
// 保存结果...

---

5. 关键注意事项

1. 模板方法的 final 修饰：
   • 防止子类重写模板方法，确保算法流程不被破坏。
2. 构造器的使用：
   • 抽象类可以有构造器，用于初始化成员变量（子类通过 super 调用）。
3. 与接口的区别：

   特性	抽象类	接口
   方法实现	可包含具体方法和抽象方法	JDK8前只能有抽象方法
   成员变量	可包含普通变量和常量	只能有常量（public static final）
   多继承	不支持（单继承）	支持多实现

---

6. 总结

• 抽象类核心：
  • 为子类提供统一模板，强制实现关键行为。
  • 通过抽象方法实现多态，支持差异化扩展。
• 模板方法模式：
  • 封装不变流程，开放扩展点，提升代码复用性。
• 适用场景：
  • 多个子类有共同流程但部分步骤不同（如数据处理、游戏角色行为）。
  • 需要限制子类对整体结构的修改时（如算法流程固定）。