抽象类与接口的区别

// 抽象类定义
public abstract class Animal {
    // 属性字段
    protected String name;
    protected int age;
    
    // 构造方法
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 抽象方法 - 没有实现
    public abstract void makeSound();
    
    // 具体方法 - 有实现
    public void sleep() {
        System.out.println(name + "正在睡觉...");
    }
    
    // 具体方法
    public String getName() {
        return name;
    }
}

1.2 接口（Interface）

接口是一种完全抽象的类型，它定义了一组方法签名，但不提供实现（Java 8 之前）。从 Java 8 开始，接口可以包含默认方法和静态方法。

// 接口定义
public interface Flyable {
    // 常量（默认 public static final）
    int MAX_ALTITUDE = 10000;
    
    // 抽象方法（默认 public abstract）
    void fly();
    
    // 默认方法（Java 8+）
    default void takeOff() {
        System.out.println("开始起飞...");
    }
    
    // 静态方法（Java 8+）
    static boolean canFly(int altitude) {
        return altitude <= MAX_ALTITUDE;
    }
}

2. 核心区别对比

特性	抽象类	接口
关键字	`abstract class`	`interface`
实例化	不能实例化	不能实例化
方法类型	抽象方法和具体方法	抽象方法、默认方法、静态方法
变量类型	任何类型的变量	只能是 `public static final` 常量
构造方法	可以有构造方法	不能有构造方法
继承方式	单继承（extends）	多实现（implements）
访问修饰符	各种访问修饰符	默认都是 public
设计目的	代码复用，模板方法模式	定义契约，实现多态

3. 语法细节区别

3.1 方法实现

抽象类：

public abstract class Vehicle {
    // 抽象方法
    public abstract void start();
    
    // 具体方法
    public void stop() {
        System.out.println("车辆停止");
    }
    
    // 私有方法
    private void checkEngine() {
        System.out.println("检查引擎");
    }
}

接口：

public interface Swimmable {
    // 抽象方法
    void swim();
    
    // 默认方法
    default void floatOnWater() {
        System.out.println("漂浮在水面上");
    }
    
    // 静态方法
    static boolean isWaterTempSuitable(int temp) {
        return temp >= 0 && temp <= 40;
    }
    
    // 私有方法（Java 9+）
    private void logSwimming() {
        System.out.println("记录游泳活动");
    }
}

3.2 继承与实现

抽象类继承：

public class Dog extends Animal {
    private String breed;
    
    public Dog(String name, int age, String breed) {
        super(name, age); // 调用父类构造方法
        this.breed = breed;
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + "汪汪叫");
    }
    
    // 可以添加新方法
    public void fetch() {
        System.out.println(name + "正在接飞盘");
    }
}

接口实现：

public class Bird extends Animal implements Flyable, Singable {
    public Bird(String name, int age) {
        super(name, age);
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + "叽叽喳喳");
    }
    
    @Override
    public void fly() {
        System.out.println(name + "在天空中飞翔");
    }
    
    @Override
    public void sing() {
        System.out.println(name + "在唱歌");
    }
    
    // 实现多个接口
    public class SuperBird extends Animal implements Flyable, Swimmable, Runnable {
        // 必须实现所有接口的抽象方法
    }
}

4. 设计理念区别

4.1 "is-a" vs "has-a" 关系

抽象类表示 "is-a"（是一个）关系：

// Dog 是一个 Animal
public class Dog extends Animal {
    // ...
}

// Car 是一个 Vehicle
public class Car extends Vehicle {
    // ...
}

接口表示 "has-a"（具有某种能力）关系：

// Bird 具有飞行能力
public class Bird implements Flyable {
    // ...
}

// Superman 具有多种能力
public class Superman implements Flyable, Swimmable, Runnable {
    // ...
}

4.2 版本演化

抽象类的演化：

public abstract class DatabaseService {
    // 添加新方法会破坏所有子类
    public abstract void connect();
    public abstract void query(String sql);
    
    // 如果添加新方法，所有子类都必须实现
    // public abstract void newMethod();
}

接口的演化（Java 8+）：

public interface DatabaseService {
    void connect();
    void query(String sql);
    
    // 可以添加默认方法而不破坏现有实现
    default void close() {
        System.out.println("默认关闭连接");
    }
    
    // 可以添加静态方法
    static String getVersion() {
        return "1.0.0";
    }
}

5. 使用场景

5.1 使用抽象类的场景

模板方法模式：

public abstract class Game {
    // 具体方法
    public final void play() {
        initialize();
        startPlay();
        endPlay();
    }
    
    // 抽象方法，由子类实现
    protected abstract void initialize();
    protected abstract void startPlay();
    protected abstract void endPlay();
}

public class Chess extends Game {
    @Override
    protected void initialize() {
        System.out.println("初始化棋盘");
    }
    
    @Override
    protected void startPlay() {
        System.out.println("开始下棋");
    }
    
    @Override
    protected void endPlay() {
        System.out.println("游戏结束");
    }
}

代码复用：

public abstract class Shape {
    protected String color;
    
    public Shape(String color) {
        this.color = color;
    }
    
    // 具体方法
    public String getColor() {
        return color;
    }
    
    // 抽象方法
    public abstract double area();
    public abstract double perimeter();
}

5.2 使用接口的场景

定义行为契约：

public interface PaymentGateway {
    boolean processPayment(double amount);
    String getTransactionId();
    default boolean validateCard(String cardNumber) {
        // 默认验证逻辑
        return cardNumber != null && cardNumber.length() == 16;
    }
}

// 多个支付实现
public class CreditCardPayment implements PaymentGateway {
    @Override
    public boolean processPayment(double amount) {
        // 信用卡支付逻辑
        return true;
    }
    
    @Override
    public String getTransactionId() {
        return "CC_" + System.currentTimeMillis();
    }
}

public class PayPalPayment implements PaymentGateway {
    @Override
    public boolean processPayment(double amount) {
        // PayPal支付逻辑
        return true;
    }
    
    @Override
    public String getTransactionId() {
        return "PP_" + System.currentTimeMillis();
    }
}

多继承模拟：

public class SmartPhone implements Callable, Browseable, Photographable {
    // 实现多个接口的方法
    @Override
    public void makeCall(String number) {
        System.out.println("拨打: " + number);
    }
    
    @Override
    public void browseWeb(String url) {
        System.out.println("浏览: " + url);
    }
    
    @Override
    public void takePhoto() {
        System.out.println("拍照");
    }
}

6. 组合使用：抽象类实现接口

public interface List<E> {
    boolean add(E element);
    E get(int index);
    int size();
}

public abstract class AbstractList<E> implements List<E> {
    protected int size = 0;
    
    @Override
    public int size() {
        return size;
    }
    
    @Override
    public boolean isEmpty() {
        return size == 0;
    }
    
    // 抽象方法，由具体子类实现
    public abstract boolean add(E element);
    public abstract E get(int index);
}

public class ArrayList<E> extends AbstractList<E> {
    private Object[] elements;
    
    public ArrayList() {
        elements = new Object[10];
    }
    
    @Override
    public boolean add(E element) {
        // 具体实现
        return true;
    }
    
    @Override
    public E get(int index) {
        // 具体实现
        return (E) elements[index];
    }
}

7. 选择推荐

什么时候用抽象类？

需要在相关类之间共享代码
需要定义非 public 的方法和字段
需要定义状态（实例变量）
需要定义构造方法
设计模板方法模式

什么时候用接口？

需要定义不相关类的行为契约
需要实现多重继承
需要定义数据类型（API 契约）
希望支持未来的扩展（默认方法）
定义回调机制或监听器

8. 实际开发建议

优先使用接口：面向接口编程，提高代码灵活性

// 好的实践：使用接口类型声明变量
List<String> list = new ArrayList<>();
Map<String, Integer> map = new HashMap<>();
PaymentGateway payment = new CreditCardPayment();

合理使用抽象类：当确实需要代码复用时

// 当有共同的基础实现时
public abstract class BaseService {
    protected Logger logger = LoggerFactory.getLogger(getClass());
    
    protected void logInfo(String message) {
        logger.info(message);
    }
    
    public abstract void execute();
}