Java 抽象类详解_Java

一、抽象类的基本定义

抽象类是用abstract关键字修饰的类，其核心作用是作为父类提供通用模板，同时强制子类实现特定方法。

1. 语法格式

// 定义抽象类
abstract class 类名 {
    // 成员变量
    // 构造方法（抽象类可以有构造方法）
    // 具体方法（有方法体）
    // 抽象方法（无方法体，用abstract修饰）
    abstract 返回值类型 方法名(参数列表);
}

2. 关键特征

不能实例化：抽象类无法通过new关键字创建对象（编译报错），只能作为父类被继承。
可包含抽象方法：抽象方法是没有方法体的方法（用abstract修饰），必须由子类实现。
可包含普通成员：抽象类可以有成员变量、构造方法、普通方法（有实现）、静态方法等，与普通类的区别仅在于 “可包含抽象方法” 和 “不能实例化”。

二、抽象方法的规则

抽象方法是抽象类的核心组成部分，它定义了子类必须实现的 “规范”，其声明有严格规则：

必须用abstract修饰，且没有方法体（不写{}，直接用;结束）。
- 示例：abstract void run();（正确）；abstract void run() {}（错误，不能有方法体）。
不能被private、final、static修饰：
- private：抽象方法需要被子类重写，private会阻止子类访问，矛盾。
- final：final方法不能被重写，而抽象方法必须被重写，矛盾。
- static：static方法属于类，无法被实例方法重写（子类的静态方法不能重写父类的静态方法）。
抽象类中可以没有抽象方法，但有抽象方法的类必须是抽象类。
（若一个类包含抽象方法却不用abstract修饰，编译报错）。

三、抽象类与子类的关系

子类继承抽象类时，必须遵循以下规则：

子类必须实现抽象类中所有的抽象方法，否则子类必须也声明为抽象类（用abstract修饰）。
示例：

// 抽象父类
abstract class animal {
    // 抽象方法：所有动物都必须实现“吃”的行为
    abstract void eat();
    // 普通方法：所有动物共有的“睡觉”行为
    void sleep() {
        system.out.println("动物睡觉");
    }
}
// 子类dog：非抽象类，必须实现eat()
class dog extends animal {
    @override
    void eat() { // 实现抽象方法
        system.out.println("狗吃骨头");
    }
}
// 子类bird：若不实现eat()，则必须声明为抽象类
abstract class bird extends animal {
    // 未实现eat()，因此bird必须是抽象类
}

子类实现抽象方法时，访问权限不能低于父类。
例如：父类抽象方法为protected void eat()，子类实现时不能用private（可⽤protected或public）。
抽象类的构造方法：
抽象类可以有构造方法（用于初始化自身成员变量），但不能直接调用（因无法实例化）。子类实例化时，会先调用抽象父类的构造方法（遵循 “先父后子” 的初始化顺序）。

示例：

abstract class vehicle {
    protected string brand;
    // 抽象类的构造方法
    public vehicle(string brand) {
        this.brand = brand;
    }
    abstract void drive();
}
class car extends vehicle {
    public car(string brand) {
        super(brand); // 调用父类构造方法
    }
    @override
    void drive() {
        system.out.println(brand + "汽车行驶");
    }
}
// 测试
public class test {
    public static void main(string[] args) {
        car car = new car("宝马"); // 子类实例化时，先调用vehicle的构造方法
        car.drive(); // 输出：宝马汽车行驶
    }
}

四、抽象类 vs 接口：核心区别

抽象类和接口（interface）都能定义规范，但在设计目的和使用场景上有本质区别：

维度	抽象类（abstract class）	接口（interface）
继承关系	单继承（子类只能继承一个抽象类）	多实现（类可以实现多个接口）
方法类型	可包含抽象方法、普通方法、静态方法、默认方法	java 8 前：只能有抽象方法；java 8 后：可包含默认方法（`default`）、静态方法
成员变量	可包含各种修饰符的成员变量（`private`、`protected`、`public`等）	只能是`public static final`修饰的常量（默认，可省略）
构造方法	有构造方法（供子类调用）	无构造方法
设计目的	体现 “is-a” 关系（继承共性），强调代码复用	体现 “like-a” 关系（实现能力），强调行为规范

示例：何时用抽象类，何时用接口？

若需要为一组相关类提供通用实现（如animal类的sleep()方法），同时强制子类实现特定行为（如eat()），用抽象类。
若需要定义一组不相关类的共同行为（如flyable接口，让bird、plane都能实现 “飞”），用接口。

五、抽象类的使用场景

抽象类适合以下场景：

提取共性，减少重复代码：当多个子类有相同的方法实现时，将这些实现放在抽象父类中，子类只需关注自身特有的实现。
例如：shape抽象类定义通用的getcolor()方法，子类circle、rectangle只需实现getarea()（面积计算因形状而异）。
定义模板方法：通过 “模板方法模式”，在抽象类中定义算法骨架，将可变步骤延迟到子类实现。
示例：

// 抽象类：定义泡茶/泡咖啡的通用流程
abstract class beverage {
    // 模板方法：固定流程（不能被重写）
    public final void prepare() {
        boilwater();    // 共性步骤：烧水
        brew();         // 抽象步骤：冲泡（子类实现）
        pourincup();    // 共性步骤：倒入杯子
        addcondiments();// 抽象步骤：加调料（子类实现）
    }
    // 抽象方法：子类实现具体冲泡方式
    abstract void brew();
    // 抽象方法：子类实现具体加调料方式
    abstract void addcondiments();
    // 共性方法：烧水
    void boilwater() {
        system.out.println("烧开水");
    }
    // 共性方法：倒入杯子
    void pourincup() {
        system.out.println("倒入杯子");
    }
}
// 子类：咖啡
class coffee extends beverage {
    @override
    void brew() {
        system.out.println("冲泡咖啡粉");
    }
    @override
    void addcondiments() {
        system.out.println("加牛奶和糖");
    }
}