Java 是一种面向对象编程语言，提供了丰富的面向对象编程机制。其中，接口和抽象类是两个重要的概念，它们在设计和实现代码时扮演着关键的角色。

接口（Interface）

定义和特性

接口是 Java 中的一种引用数据类型，是抽象方法的集合。接口中的方法没有方法体（即没有具体的实现），接口中也可以包含常量（默认是 public static final）。接口是一种契约，规定了类必须提供的方法。以下是接口的一些主要特性：

1. 接口中的方法默认是 public 和 abstract：所有在接口中声明的方法默认都是公开的和抽象的。
2. 接口中的变量默认是 public static final：接口中声明的变量默认是常量。
3. Java 8 引入了默认方法和静态方法：默认方法（default）允许在接口中提供方法的默认实现，静态方法（static）可以在接口中提供具体的静态方法实现。
4. 接口不能包含实例字段：接口中只能包含常量，不能有实例变量。
5. 多继承：一个类可以实现多个接口，这在 Java 中提供了一种多继承的方式。

使用场景

接口主要用于以下场景：

1. 定义契约：接口用于定义类必须实现的方法，这对API设计尤为重要。通过接口，可以确保实现类提供必要的功能，而不限制其具体实现方式。
2. 解耦：接口通过抽象层来解耦系统的不同部分，使得各部分可以独立开发和维护。
3. 多态性：通过接口，可以实现对象的多态性。例如，可以用接口类型的引用指向实现类的实例，从而可以在运行时动态地决定具体的实现。

示例

// 定义一个接口
public interface Animal {
    void eat();
    void sleep();
}

// 实现接口的类
public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
    
    @Override
    public void sleep() {
        System.out.println("Dog is sleeping");
    }
}

抽象类（Abstract Class）

定义和特性

抽象类是包含一个或多个抽象方法的类。抽象类不能被实例化，只能被继承。抽象类中的抽象方法没有方法体，需要在子类中实现。以下是抽象类的一些主要特性：

1. 抽象方法：抽象类可以包含抽象方法，这些方法没有实现，需要在子类中实现。
2. 非抽象方法：抽象类也可以包含具体的方法（即有实现的方法）。
3. 字段：抽象类可以包含字段，可以是实例字段或静态字段。
4. 构造方法：抽象类可以有构造方法，尽管不能实例化，但构造方法可以被子类调用。
5. 单继承：一个类只能继承一个抽象类。

使用场景

抽象类主要用于以下场景：

1. 代码复用：抽象类可以包含具体的方法实现，这些方法可以被子类继承和使用，从而实现代码复用。
2. 定义模板：抽象类可以定义模板方法，提供基本的算法结构，具体实现延迟到子类。
3. 限制继承：抽象类可以作为基类，提供基本的功能和框架，但限制子类必须实现某些方法。

示例

// 定义一个抽象类
public abstract class Animal {
    public abstract void eat();
    public abstract void sleep();
    
    public void breathe() {
        System.out.println("Animal is breathing");
    }
}

// 实现抽象类的子类
public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
    
    @Override
    public void sleep() {
        System.out.println("Dog is sleeping");
    }
}

接口与抽象类的区别

1. 目的不同：接口用于定义契约，提供一组方法规范，而抽象类用于代码复用和定义模板。
2. 多继承：类可以实现多个接口，但只能继承一个抽象类。
3. 成员：接口只能包含常量和抽象方法（Java 8之后可以有默认方法和静态方法），而抽象类可以包含字段、具体方法和抽象方法。
4. 构造方法：接口不能有构造方法，而抽象类可以有构造方法。
5. 访问修饰符：接口中的方法默认是 public，而抽象类中的方法可以有各种访问修饰符（public、protected、private）。

使用场景对比

何时使用接口

• 需要实现多继承：当一个类需要从多个来源继承行为时，接口是最佳选择。
• 定义契约而非实现：当需要定义一个行为规范而不关心具体实现时，使用接口。
• 解耦：接口可以用于解耦代码，实现低耦合高内聚。

何时使用抽象类

• 代码复用：当多个类有共同的行为或属性时，可以使用抽象类来提供这些通用代码。
• 定义模板方法：当需要定义一个基本算法的骨架，并允许子类实现具体步骤时，使用抽象类。
• 需要构造函数：当类需要初始化某些状态或执行某些操作时，可以使用抽象类提供构造函数。

实际应用中的选择

在实际应用中，接口和抽象类的选择通常取决于具体的需求和设计目标。以下是一些实际应用中的考虑因素：

1. 扩展性：如果预期某个类层次结构会频繁扩展，引入新功能，那么接口提供的灵活性和多继承能力更适合。
2. 现有类的改造：如果需要对现有类进行改造，使其符合新的接口规范，那么可以通过实现接口而不改变类的继承关系。
3. 模板方法模式：当采用模板方法模式设计时，抽象类更适合，因为它可以提供基本的算法结构和部分实现。
4. 性能：在某些情况下，抽象类可能比接口具有更好的性能，因为调用具体方法时可以避免接口调用的额外开销。

综合实例

为了更好地理解接口和抽象类的实际应用，以下是一个综合实例，展示如何在一个系统中同时使用接口和抽象类。

// 定义一个接口
public interface Movable {
    void move();
}

// 定义一个抽象类
public abstract class Vehicle implements Movable {
    protected String brand;
    protected String model;
    
    public Vehicle(String brand, String model) {
        this.brand = brand;
        this.model = model;
    }
    
    public void start() {
        System.out.println(brand + " " + model + " is starting");
    }
    
    public abstract void fuelUp();
}

// 定义一个具体的子类
public class Car extends Vehicle {
    public Car(String brand, String model) {
        super(brand, model);
    }
    
    @Override
    public void move() {
        System.out.println(brand + " " + model + " is moving");
    }
    
    @Override
    public void fuelUp() {
        System.out.println(brand + " " + model + " is fueling up");
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        Car car = new Car("Toyota", "Corolla");
        car.start();
        car.move();
        car.fuelUp();
    }
}

在这个综合实例中，我们定义了一个 Movable 接口和一个 Vehicle 抽象类。Vehicle 抽象类实现了 Movable 接口，并提供了一些通用的功能。具体的 Car 类继承了 Vehicle 抽象类，并实现了抽象方法 fuelUp 和接口方法 move。

接口和抽象类是 Java 中两个重要的概念，它们在设计和实现代码时扮演着不同的角色。接口用于定义类必须实现的方法，提供了一种多继承的方式，适合用于解耦和定义契约。

抽象类用于提供部分实现和代码复用，适合用于定义模板方法和提供基础功能。在实际应用中，选择接口还是抽象类取决于具体的设计需求和目标。理解并灵活运用接口和抽象类，可以使代码更具扩展性、可维护性和可读性。

黑马程序员免费预约咨询