问题

接口能继承接口吗？抽象类能实现接口吗？抽象类能继承具体类吗？

答案

核心结论

三个问题的答案都是可以：

1. 接口可以继承接口，且支持多继承
2. 抽象类可以实现接口，可以不实现接口的所有方法
3. 抽象类可以继承具体类，遵循单继承规则

详细说明

1. 接口继承接口

特点：

• 使用 extends 关键字（不是 implements）
• 支持多继承，可以同时继承多个接口
• 子接口会继承父接口的所有抽象方法

代码示例：

// 父接口
interface Flyable {
    void fly();
}

interface Swimmable {
    void swim();
}

// 接口继承接口，支持多继承
interface Amphibious extends Flyable, Swimmable {
    void walk();
}

// 实现类需要实现所有方法
class Duck implements Amphibious {
    @Override
    public void fly() {
        System.out.println("鸭子飞行");
    }

    @Override
    public void swim() {
        System.out.println("鸭子游泳");
    }

    @Override
    public void walk() {
        System.out.println("鸭子行走");
    }
}

2. 抽象类实现接口

特点：

• 使用 implements 关键字
• 可以不实现接口的所有方法（留给子类实现）
• 也可以选择实现部分或全部方法

代码示例：

interface Animal {
    void eat();
    void sleep();
    void move();
}

// 抽象类实现接口，可以不实现所有方法
abstract class Mammal implements Animal {
    // 实现部分方法
    @Override
    public void sleep() {
        System.out.println("哺乳动物睡觉");
    }

    // eat() 和 move() 留给子类实现
}

// 具体子类必须实现剩余的抽象方法
class Dog extends Mammal {
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }

    @Override
    public void move() {
        System.out.println("狗跑动");
    }
}

3. 抽象类继承具体类

特点：

• 使用 extends 关键字
• 遵循 Java 的单继承规则
• 可以继承具体类的所有非 private 成员
• 可以添加新的抽象方法

代码示例：

// 具体类
class Vehicle {
    protected String brand;

    public Vehicle(String brand) {
        this.brand = brand;
    }

    public void start() {
        System.out.println(brand + " 启动");
    }
}

// 抽象类继承具体类
abstract class Car extends Vehicle {
    public Car(String brand) {
        super(brand);
    }

    // 添加新的抽象方法
    public abstract void drive();

    // 可以重写父类方法
    @Override
    public void start() {
        System.out.println("汽车 " + brand + " 点火启动");
    }
}

// 具体子类
class Tesla extends Car {
    public Tesla() {
        super("特斯拉");
    }

    @Override
    public void drive() {
        System.out.println("特斯拉自动驾驶");
    }
}

综合示例

// 接口继承接口
interface Readable {
    void read();
}

interface Writable {
    void write();
}

interface Storage extends Readable, Writable {
    void delete();
}

// 具体类
class Device {
    protected String name;

    public Device(String name) {
        this.name = name;
    }
}

// 抽象类继承具体类并实现接口
abstract class StorageDevice extends Device implements Storage {
    public StorageDevice(String name) {
        super(name);
    }

    // 实现部分接口方法
    @Override
    public void delete() {
        System.out.println(name + " 删除数据");
    }

    // read() 和 write() 留给子类实现
}

// 具体实现类
class HardDisk extends StorageDevice {
    public HardDisk() {
        super("硬盘");
    }

    @Override
    public void read() {
        System.out.println("硬盘读取数据");
    }

    @Override
    public void write() {
        System.out.println("硬盘写入数据");
    }
}

关键对比

场景	关键字	多继承	是否必须实现所有方法
接口继承接口	extends	✅ 支持	否（接口本身不实现）
抽象类实现接口	implements	✅ 支持多个接口	否（可留给子类）
抽象类继承具体类	extends	❌ 单继承	否��可添加新抽象方法）

面试要点总结

1. 接口继承接口：
   • 用 extends，支持多继承
   • 子接口会累积所有父接口的方法
2. 抽象类实现接口：
   • 用 implements，可以不实现所有方法
   • 体现了抽象类的灵活性
3. 抽象类继承具体类：
   • 用 extends，单继承
   • 可以在具体类基础上添加抽象行为
4. 设计原则：
   • 接口定义能力（can-do）
   • 抽象类定义本质（is-a）
   • 具体类提供完整实现

这道题考察的是对 Java 面向对象继承体系的深入理解，是面试中的高频考点。