接口和抽象类

Java 接口（Interface）与抽象类（Abstract Class）详解

接口和抽象类是 Java 中实现抽象编程的两种核心机制，均用于定义规范并实现代码复用，但在设计目的和使用场景上有显著差异。本文将从定义、特性、演化及对比等方面，全面解析两者的核心区别与适用场景。

抽象类（Abstract Class）

抽象类是包含抽象方法的类，既可以提供部分方法的实现，也可以声明未实现的抽象方法，强制子类完成具体逻辑。其核心是 “部分抽象”—— 作为父类为子类提供基础实现，同时保留扩展空间。

核心特性

抽象方法：用 abstract 修饰的方法，仅有声明无方法体（如 abstract void func();），必须由子类重写。
不能实例化：抽象类无法通过 new 创建对象，需由实现了所有抽象方法的子类实例化。
可包含具体方法：抽象类可以有非抽象方法（带方法体），子类可直接复用这些实现。
可包含实例变量：支持定义非静态成员变量，可通过非抽象方法操作这些变量（维护对象状态）。
构造器：抽象类有构造器（用于子类初始化时调用），但不能直接用于实例化自身。

语法规则

类用 abstract 修饰（如 public abstract class Animal）。
抽象方法不能用 private、final、static 修饰（这些修饰符会阻止子类重写）。
若子类未实现抽象类的所有抽象方法，则子类必须也声明为抽象类。

// 抽象类示例
public abstract class Animal {
    // 实例变量（维护对象状态）
    protected String name;

    // 构造器（供子类调用）
    public Animal(String name) {
        this.name = name;
    }

    // 抽象方法（强制子类实现）
    public abstract void eat();

    // 具体方法（提供默认实现）
    public void sleep() {
        System.out.println(name + "在睡觉");
    }
}

// 子类实现抽象类
public class Dog extends Animal {
    public Dog(String name) {
        super(name); // 调用父类构造器
    }

    // 必须重写抽象方法
    @Override
    public void eat() {
        System.out.println(name + "吃骨头");
    }
}

设计目的

抽象类用于表达 “is-a” 关系（子类是父类的具体类型），适用于存在共性实现的场景。例如：

动物（Animal）作为抽象类，包含所有动物共有的 sleep 方法，同时声明每个动物必须实现的 eat 方法；
狗（Dog）、猫（Cat）作为子类，分别实现自己的 eat 逻辑，复用 sleep 方法。

接口（Interface）

接口是完全抽象的规范定义，最初仅包含抽象方法，Java 8 后支持默认方法和静态方法，Java 9 进一步支持私有方法。其核心是 “行为规范”—— 定义某类事物必须具备的能力，不关注具体实现。

核心特性（Java 8+）

抽象方法：接口默认方法为 public abstract（可省略修饰符），必须由实现类重写。
默认方法：用 default 修饰，带方法体（如 default void func() { ... }），实现类可直接复用或重写，用于接口演化（新增方法不破坏现有实现）。
静态方法：用 static 修饰，属于接口本身（如 static void tool() { ... }），可直接通过接口名调用（如 InterfaceName.tool()），用于提供工具逻辑。
私有方法（Java 9+）：用 private 修饰，仅接口内部的默认方法可调用，用于复用默认方法的逻辑。
成员变量：接口中的变量默认是 public static final（常量），必须初始化，不能被修改。
不能实例化：接口无法通过 new 创建对象，需由实现类实现所有抽象方法后实例化。
多实现：一个类可实现多个接口（用 implements 关键字），突破类的单继承限制。

语法规则

接口用 interface 修饰（如 public interface Flyable）。
接口没有构造器（无法实例化）。
实现类用 implements 关键字实现接口，必须重写所有抽象方法（默认方法可选重写）。

// 接口示例（Java 8+）
public interface Flyable {
    // 抽象方法（默认 public abstract）
    void fly();

    // 默认方法（提供基础实现）
    default void prepare() {
        System.out.println("准备飞行");
        checkWings(); // 调用私有方法
    }

    // 静态方法（工具逻辑）
    static void showMaxHeight() {
        System.out.println("最大飞行高度：1000米");
    }

    // 私有方法（复用默认方法逻辑）
    private void checkWings() {
        System.out.println("检查翅膀状态");
    }
}

// 实现类
public class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("鸟扇动翅膀飞行");
    }

    // 可选：重写默认方法
    @Override
    public void prepare() {
        Flyable.super.prepare(); // 调用接口默认实现
        System.out.println("鸟整理羽毛");
    }
}

特殊场景：默认方法冲突

当一个类实现多个接口，且接口包含同名同参的默认方法时，必须重写该方法以解决冲突（否则编译报错）。

interface A {
    default void hello() {
        System.out.println("A.hello");
    }
}

interface B {
    default void hello() {
        System.out.println("B.hello");
    }
}

// 实现多个接口，必须重写冲突的默认方法
class C implements A, B {
    @Override
    public void hello() {
        A.super.hello(); // 可选：调用A的默认实现
        B.super.hello(); // 可选：调用B的默认实现
        System.out.println("C.hello");
    }
}

设计目的

接口用于表达 “can-do” 关系（类具备某种能力），适用于定义行为规范且需要多实现的场景。例如：

飞翔（Flyable）作为接口，定义 fly 方法，鸟（Bird）、飞机（Plane）等不同类型的类均可实现，表达 “具备飞翔能力”；
接口的多实现允许一个类同时具备多种能力（如 Bird 可同时实现 Flyable 和 Swimmable）。

抽象类与接口的核心对比

维度	抽象类（Abstract Class）	接口（Interface）
继承 / 实现	单继承（子类用 `extends`）	多实现（类用 `implements`）
方法类型	可包含抽象方法、具体方法	抽象方法、默认方法（Java 8+）、静态方法（Java 8+）、私有方法（Java 9+）
成员变量	可包含实例变量（非静态、可修改）	仅允许常量（`public static final`，不可修改）
构造器	有构造器（供子类初始化调用）	无构造器（无法实例化）
设计意图	表达 “is-a” 关系（子类是父类的具体类型）	表达 “can-do” 关系（类具备某种能力）
实例化条件	子类实现所有抽象方法后可实例化	实现类实现所有抽象方法后可实例化
访问修饰符	抽象方法可被 `public`/`protected` 修饰	抽象方法默认 `public`（仅允许 `public`）
扩展兼容性	新增方法可能破坏子类（需子类同步修改）	默认方法支持平滑扩展（不强制子类修改）

如何选择：抽象类 vs 接口？

优先用接口的场景：
- 需要定义行为规范（如 “飞翔”“序列化”），且可能被多个无关类实现；
- 需要多实现（一个类具备多种能力）；
- 接口的默认方法和静态方法可满足代码复用需求，无需维护对象状态。
优先用抽象类的场景：
- 需要为子类提供共性实现（如多个子类共享相同逻辑）；
- 需要维护对象状态（依赖实例变量）；
- 表达明确的 “is-a” 关系（如 “Dog 是 Animal”）