Java 接口和抽象类 ​

在 Java 中，接口和抽象类都是用于实现面向对象编程的重要机制。本文将介绍 Java 中的接口和抽象类的定义、特点、用法以及它们之间的区别。

接口（Interface） ​

定义 ​

接口是 Java 语言中的一种约定，它可以看成是一种契约，要求实现它的类必须实现接口中的所有方法。在 Java 中，接口类似于抽象类，但是它比抽象类更加抽象和规范，因为接口只包含了方法的声明，而没有方法的实现。因此，接口的使用可以帮助我们实现代码的多态性、灵活性和规范性，提高了代码的可扩展性和可维护性。

Java 接口是一种特殊的类，它只包含方法的声明而没有方法的实现。接口可以看做是一组合同，它规定了实现该接口的类必须遵守的标准。一个类可以实现多个接口。

定义格式 ​

在 Java 中，接口定义的关键字为 interface，其语法格式如下：

[public] interface InterfaceName [extends SuperInterfaces] {
    // 常量定义
    [public static final] dataType CONSTANT_NAME = constantValue;

    // 方法定义
    [public] return_type methodName([param_list]);
}

其中，方括号里面的关键字表示可选的部分。

简单写法：

public interface 接口名称 {
    // 常量声明
    // 抽象方法声明
}

特点 ​

1. 接口中的方法都不能有方法体，只能是方法声明。
2. 接口中的变量默认是常量，即 public static final，不能被修改。
3. 接口不能被实例化，必须被实现。

用法 ​

下面是一个示例代码，我们以动物和会飞的动物为例，使用接口来对它们进行抽象和规范。

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

// 定义一个会飞的接口
public interface Flyable {
    public void fly();
}

// 实现一只鹦鹉
public class Parrot implements Animal, Flyable {
    @Override
    public void eat() {
        System.out.println("鹦鹉正在吃东西");
    }

    @Override
    public void fly() {
        System.out.println("鹦鹉正在飞翔");
    }
}

// 实现一只老虎
public class Tiger implements Animal {
    @Override
    public void eat() {
        System.out.println("老虎正在吃东西");
    }
}

在上面的代码中，我们定义了一个 Animal 接口，表示动物，包含了一个 eat() 方法，表示动物吃东西的操作。然后，我们定义了一个 Flyable 接口，表示会飞的动物，包含了一个 fly() 方法，表示会飞的操作。接着，我们分别创建了 Parrot 类和 Tiger 类，它们都实现了 Animal 接口，但是只有 Parrot 类实现了 Flyable 接口。这样，我们就可以通过调用 eat() 方法和 fly() 方法来完成吃东西和飞翔的操作。

public class Demo {
    public static void main(String[] args) {
        Animal a1 = new Parrot();
        Animal a2 = new Tiger();
        Flyable f1 = new Parrot();
        a1.eat(); // 鹦鹉正在吃东西
        a2.eat(); // 老虎正在吃东西
        f1.fly(); // 鹦鹉正在飞翔
    }
}

在上面的代码中，我们创建了两个 Animal 接口的实例，一个是 Parrot 类的实例，一个是 Tiger 类的实例。还创建了一个 Flyable 接口的实例，也是 Parrot 类的实例。通过调用 eat() 方法和 fly() 方法，我们分别完成了鹦鹉的吃东西和飞翔，以及老虎的吃东西。因此，通过接口，我们可以实现多态，可以让一个对象表现出不同的行为，提高了代码的可扩展性和可维护性。

抽象类（Abstract Class） ​

定义 ​

抽象类可以看成是一种不完全的类，它同时具有类和接口的特征，可以包含抽象方法和具体方法，但是不能直接实例化。在 Java 中，抽象类用于对类进行更高层次的抽象和规范，它是一种用于派生子类的基类或蓝本，不能被直接实例化，而是需要子类继承并实现其中的抽象方法。

定义格式 ​

public abstract class 抽象类名称 {
    // 抽象方法声明
    // 具体方法声明
}

特点 ​

1. 抽象类可以包含一些具体方法的实现，但其中至少有一个抽象方法。
2. 抽象类中的抽象方法只有方法声明而没有方法实现。
3. 抽象类必须被子类实现。

用法 ​

我们可以用生活中的例子来解释抽象类。比如说，我们可以定义一种抽象类 Animal（动物），这个抽象类可以包含一些具体的属性和方法，比如动物的名字、年龄、颜色、食性等等。但是，由于不同的动物之间有很大的区别，我们不能把它们定义在同一个类中。

因此，我们可以定义子类来继承这个抽象类，并且实现其中的一些抽象方法，比如 eat()、sleep() 等等。每个具体的动物子类都必须实现这些方法，以体现它们各自的特点和习性。但是，具体的动物子类也可以添加自己特有的属性和方法，以进一步区分和体现它们各自的特色。

比如，我们可以定义一个抽象类 Animal，其中包含一个抽象方法 makeSound() 表示动物发出的声音以及几个具体方法 setName()、getName()、setAge()、getAge() 表示动物的姓名和年龄等属性。然后，我们可以定义具体的动物子类如 Dog、Cat、Tiger 等等，这些子类都必须继承 Animal 类，实现其中的 makeSound() 方法，并且可以添加自己特有的属性和方法。

下面是一个示例代码：

// 定义一个动物抽象类
public abstract class Animal {
    private String name;
    private int age;

    public Animal() {}

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public abstract void makeSound();

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return this.age;
    }
}

// 定义狗子类
public class Dog extends Animal {
    public Dog() {
        super();
    }

    public Dog(String name, int age) {
        super(name, age);
    }

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

// 定义猫子类
public class Cat extends Animal {
    public Cat() {
        super();
    }

    public Cat(String name, int age) {
        super(name, age);
    }

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

在上面的代码中，我们定义了一个抽象类 Animal，其中包含了具体的属性 name 和 age，抽象方法 makeSound()，以及具体的方法 setName()、getName()、setAge()、getAge()。然后，我们又定义了 Dog 和 Cat 两个具体的子类，它们都继承了 Animal 类，具体地实现了 makeSound() 方法。

测试：

// 测试代码
public class Demo {
    public static void main(String[] args) {
        Animal dog = new Dog("小黄", 3);
        Animal cat = new Cat("小花", 2);
        dog.makeSound(); // 汪汪汪
        cat.makeSound(); // 喵喵喵
        System.out.println(dog.getName() + " " + dog.getAge()); // 小黄 3
        System.out.println(cat.getName() + " " + cat.getAge()); // 小花 2
    }
}

以上的测试代码中，我们可以通过实例化 Dog 和 Cat 来进行动物声音的测试，并且可以获取到它们各自的姓名和年龄属性。虽然 Animal 类并不能被直接实例化，但是它可以帮助我们更好地进行子类的抽象和规范。

接口和抽象类的区别 ​

Java 接口和抽象类是两种不同的抽象概念，它们之间有以下几个主要区别：

1. 实现方式

   抽象类是类的一种，可以被继承，它可以包含抽象方法、具体方法，也可以有成员变量、静态方法等等。子类继承抽象类时，必须实现其抽象方法。 接口是一种不包含任何方法实现的声明，描述的是一个类所具有的一组方法。类可以实现多个接口，从而具有多重继承的特性，实现接口的类必须实现其中的所有方法。

2. 方法特征

   抽象类中可以有包含方法体的具体方法，但也可以有抽象方法，需要在子类中进行实现。

   接口中的所有方法都是抽象方法，没有任何方法体，需要在实现类中进行具体的实现。

3. 构造方法

   抽象类可以有构造方法，用于完成一些基本的初始化操作。

   接口不能有构造方法，因为接口不需要进行初始化操作。

4. 访问修饰符

   抽象类中可以有多种访问修饰符的方法，例如 public、protected、private 等。

   接口中的方法默认为 public，不能为 private、protected 等其他访问修饰符。

5. 实现限制

   一个类只能继承一个抽象类，但可以同时实现多个接口。

   抽象类只能通过继承来实现，而接口可以通过实现多态性、扩展性、灵活性来实现。

6. 作用

   抽象类主要用于抽象出一些共性的代码，提供一些通用的实现方法，而接口主要用于规范类的行为和应用程序接口。

   总之，抽象类和接口虽然有很多相似之处，但两者的差异也非常明显，需要根据不同情况的需求选择合适的方式。

如何选择？ ​

对于初学者来说，接口和抽象类的边界似乎很难区分，导致我们在选择的过程中无所适从，我们应该根据不同的需求选择适合的抽象类或者接口。下面是一些选择的建议：

• 如果我们要定义一个“is-a”（是一个）关系的抽象概念，就应该使用抽象类。例如 Animal 是一个抽象概念，可以定义为抽象类。
• 如果我们要定义一个“has-a”（具有）关系的抽象概念，就应该使用接口。例如 Flyable 描述了一种能力，可以定义为接口。
• 如果我们需要使用多继承，就应该考虑使用接口。因为 Java 中，类只能继承一个父类，而可以实现多个接口，能够更好地实现代码复用的目标。
• 如果我们只是想简单地封装一些公共代码以便复用，可以考虑使用抽象类，因为它比接口更灵活，可以提供具体的方法实现。
• 如果我们想设计一个类层次结构，并且其中某些方法可能只有部分子类需要实现，可以使用抽象类，因为它可以提供具体的方法实现，并且子类可以选择性地覆盖这些方法。
• 如果我们想定义一些规范和标准，而不关心具体的实现和细节，可以使用接口，因为它只定义了方法的规范，没有方法的具体实现。

总的来说，抽象类和接口都有各自的优点和适用场景，在实际开发过程中，应该根据实际需求选择合适的方式。如果我们只需要定义方法的规范，可以使用接口；如果还需要提供一些基本的代码实现，可以考虑使用抽象类。

总结 ​

接口和抽象类的使用都能帮助我们实现面向对象编程思想的多态机制，但它们各有不同的使用场景和语法规范。在实际使用中，根据需求选择不同的机制能够更好地满足我们的需求。