引言

在Java中，接口和抽象类是两种用来定义类行为的关键机制。它们在实现多态性、代码复用和系统设计中扮演着重要角色。然而，这两者有着不同的特性和使用场景。本文将深入探讨Java接口和抽象类的区别，并提供详细的代码示例来帮助读者更好地理解它们的应用场景。

一、接口

接口的定义

接口是Java中的一种引用类型，是抽象方法的集合。接口可以被类实现，并且一个类可以实现多个接口，从而实现多重继承的效果。接口主要用来定义一组行为，而不涉及具体的实现。

简单来说，接口就是对行为的抽象。

接口的特性

全局常量：接口中的变量默认为 public static final
抽象方法：接口中的方法默认是 public abstract，必须由实现类提供具体实现
默认方法：从Java 8开始，接口可以有默认方法（default），允许接口提供方法的具体实现
静态方法：从Java 8开始，接口可以有静态方法
私有方法：从Java 9开始，接口可以有私有方法，仅供接口内部调用

接口示例

public interface MyInterface {

    // 全局常量
    int MY_CONSTANT = 10;

    // 抽象方法
    void myMethod();

    // 默认方法
    default void myDefaultMethod() {
        System.out.println("myDefaultMethod...");
    }

    // 静态方法
    static void myStaticMethod() {
        System.out.println("myStaticMethod...");
    }
}

我们可以通过反射来验证接口的常量和方法带有默认的访问修饰符和签名。

public class MyInterfaceTest {

    public static void main(String[] args) throws NoSuchFieldException, NoSuchMethodException {
        Field field = MyInterface.class.getField("MY_CONSTANT");
        int fieldModifiers = field.getModifiers();
        System.out.println("MY_CONSTANT修饰符：" + Modifier.toString(fieldModifiers));

        Method method = MyInterface.class.getMethod("myMethod");
        int methodModifiers = method.getModifiers();
        System.out.println("myMethod修饰符: " + Modifier.toString(methodModifiers));
    }
}

输出结果：

MY_CONSTANT修饰符：public static final
myMethod修饰符: public abstract

二、抽象类

抽象类的定义

抽象类是一种可以包含抽象方法（没有方法体的方法）的类。抽象类不能实例化，需要被其他类继承，并实现其抽象方法。抽象类可以包含普通的成员变量和已实现的方法。

抽象类是对整个类进行抽象，包括属性、行为。

抽象类的特性

抽象方法：抽象类可以包含抽象方法，必须由子类实现
已实现的方法：抽象类可以包含具体的方法，这些方法可以直接被子类继承或重写
成员变量：抽象类可以有普通的成员变量
构造函数：抽象类可以有构造函数，用于子类初始化

抽象类示例

public abstract class MyAbstractClass {

    // 成员变量
    String name;

    // 抽象方法
    abstract void myAbstractMethod();

    // 已实现的方法
    void myMethod() {
        System.out.println("I am " + name);
    }

    // 构造函数
    MyAbstractClass(String name) {
        this.name = name;
    }
}

三、接口与抽象类的比较

特性	接口	抽象类
继承方式	一个类可以实现多个接口	一个类只能继承一个抽象类
成员变量	只能包含 public static final 类型的常量	可以包含各种访问修饰符的成员变量
方法	只能有抽象方法、默认方法和静态方法	可以有抽象方法和具体方法
访问修饰符	默认是 public，不能使用 protected 和 private	可以使用任何访问修饰符
构造函数	没有构造函数	可以有构造函数
多重继承	支持（通过实现多个接口）	不支持（单一继承）
使用场景	定义类的行为，提供一个行为契约	提供一个类的基本实现，供子类扩展

四、使用案例

场景：动物与行为

定义一个动物的系统，所有的动物都会发出声音和吃东西。一些动物还会游泳或飞翔。我们将使用接口和抽象类来建模这个系统。

定义基础接口：Animal接口定义了所有动物的基本行为
定义功能接口：Swimmable 和 Flyable 接口定义了游泳和飞翔的能力
Mammal 抽象类实现了 Animal 接口，并提供了一些共同的实现

代码实现：

// 基础接口
interface Animal {
    void makeSound();

    default void eat() {
        System.out.println("Animal is eating...");
    }
}

// 功能接口
interface Swimmable {
    void swim();
}

interface Flyable {
    void fly();
}

// 抽象类
abstract class Mammal implements Animal {
    String name;

    Mammal(String name) {
        this.name = name;
    }

    // 具体方法（可以重写接口的默认方法）
    @Override
    public void eat() {
        System.out.println(name + " is eating...");
    }
}

// 实现类
class Dog extends Mammal implements Swimmable {
    Dog(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println("Bark");
    }

    // 实现游泳这个功能接口
    @Override
    public void swim() {
        System.out.println(name + " is swimming...");
    }
}

class Bird implements Animal, Flyable {
    @Override
    public void makeSound() {
        System.out.println("Chirp");
    }

    // 实现飞翔这个功能接口
    @Override
    public void fly() {
        System.out.println("Bird is flying...");
    }
}

public class Test {

    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        dog.makeSound(); // 输出：Bark
        dog.eat();       // 输出：Buddy is eating...
        dog.swim();      // 输出：Buddy is swimming...

        Bird bird = new Bird();
        bird.makeSound(); // 输出：Chirp
        bird.fly();       // 输出：Bird is flying...
        bird.eat();       // 输出：Animal is eating... (默认方法)
    }
}

从上面这个案例我们可以看到，接口的默认方法子类可以重写也可以不重写（eat()方法）。JDK8的接口提供默认方法，可以让子类在实现该接口时，不用强制去实现这个默认方法代表的行为。

五、总结

通过上述案例，可以清楚地看到接口和抽象类在Java中的应用场景和区别。接口主要用于定义行为，而抽象类提供一个基础实现供子类扩展。在设计系统时，根据需求选择接口或抽象类，可以提高代码的灵活性和可维护性。掌握这两者的区别和使用方法，是深入理解Java面向对象编程的重要一步。

从另一角度来说，抽象类是一种模板设计，接口是一种规范。

Java中的接口与抽象类：介绍与比较

引言