抽象类与接口的区别

在Java中，接口（Interface）和抽象类（Abstract Class）是面向对象编程中两种重要的抽象机制，它们的核心区别体现在设计目的、功能特性和使用场景上。以下是它们的对比：

一、核心区别总结

二、详细对比

1. 方法实现

• 接口：
  • Java 8 前只能声明抽象方法（无方法体）
  • Java 8 后允许定义默认方法（default 修饰）和静态方法

public interface Animal {
    // 抽象方法（隐含 public abstract）
    void eat(); 
    
    // 默认方法（提供默认实现）
    default void sleep() {
        System.out.println("Animal is sleeping");
    }
    
    // 静态方法
    static void breathe() {
        System.out.println("Animal is breathing");
    }
}

• 抽象类：
  • 可以同时包含抽象方法（abstract 修饰）和具体实现方法
  • 抽象方法强制子类实现，具体方法可直接复用

public abstract class Bird {
    // 抽象方法
    public abstract void fly(); 
    
    // 具体方法
    public void sing() {
        System.out.println("Bird is singing");
    }
}

2. 成员变量

• 接口：
  • 所有变量默认是 public static final（常量），必须显式初始化

public interface Constants {
    int MAX_SPEED = 100; // 等价于 public static final int MAX_SPEED = 100;
}

• 抽象类：
  • 可以定义普通成员变量、静态变量和常量，支持任意访问修饰符

public abstract class Vehicle {
    protected int speed;      // 普通变量
    private static String type = "Vehicle"; // 静态变量
    public static final int WHEELS = 4; // 常量
}

3. 构造方法

• 接口：
  • 不能定义构造方法，因为接口不能被实例化
• 抽象类：
  • 可以有构造方法（即使抽象类本身不能被实例化），用于初始化子类公共属性

public abstract class Shape {
    private String color;
    
    // 抽象类的构造方法
    public Shape(String color) {
        this.color = color;
    }
    
    public String getColor() {
        return color;
    }
}

public class Circle extends Shape {
    public Circle(String color) {
        super(color); // 调用抽象类构造方法
    }
}

4. 继承与实现

• 接口：
  • 一个类可以实现多个接口（解决Java单继承的局限性）

public class Dog implements Runnable, Barkable {
    // 必须实现所有接口的抽象方法
}

• 抽象类：
  • 一个类只能继承一个抽象类（单继承限制）

public class Eagle extends Bird {
    // 必须实现抽象类的抽象方法
}

三、使用场景

1. 何时用接口？

• 定义行为规范：
  例如，Comparable 接口定义对象比较规则，任何类实现它即可支持排序。
• 实现多重继承：
  需要让一个类具备多种能力（如同时实现 Flyable 和 Swimmable）。
• 解耦组件：
  在模块化设计中，接口作为契约，降低代码耦合度（如Spring的依赖注入）。

2. 何时用抽象类？

• 共享代码逻辑：
  多个相关类有共同代码，可将公共实现提取到抽象类中（如AbstractList为List提供通用实现）。

• 定义类的基础结构：
  抽象类适合表示“是什么”的层级关系（如Animal抽象类派生出Cat和Dog）。

• 控制子类扩展方式：
  通过抽象类的模板方法模式，固定某些步骤的执行流程。

四、示例对比

场景：设计“支付”功能

• 接口方式：

public interface Payment {
    void pay(double amount); // 支付行为规范
}

// 不同支付方式独立实现接口
public class Alipay implements Payment {
    @Override
    public void pay(double amount) { /* 支付宝支付逻辑 */ }
}

public class WechatPay implements Payment {
    @Override
    public void pay(double amount) { /* 微信支付逻辑 */ }
}

• 抽象类方式：

public abstract class BasePayment {
    protected String account;
    
    public BasePayment(String account) {
        this.account = account;
    }
    
    // 公共逻辑：验证账户
    protected boolean validateAccount() {
        return account != null && !account.isEmpty();
    }
    
    // 抽象方法：子类必须实现支付逻辑
    public abstract void pay(double amount);
}

public class CreditCardPayment extends BasePayment {
    public CreditCardPayment(String account) {
        super(account);
    }
    
    @Override
    public void pay(double amount) {
        if (validateAccount()) { 
            /* 信用卡支付逻辑 */ 
        }
    }
}

五、总结

• 接口：轻量级的协议，强调“能做什么”，适合定义跨类别的行为规范和实现多态。
• 抽象类：部分实现的基类，强调“是什么”，适合代码复用和定义类层次结构。
• 实际开发中：优先用接口定义行为，用抽象类共享代码，两者常结合使用（如抽象类实现接口，提供部分默认实现）。