详解Java 抽象类和接口，分析其区别和应用场景

现在面试老是会被问八股文，偶尔就会有面试官问抽象类和接口的区别，今天来详细说说这两个玩意

一、抽象类

1.1 抽象类的定义

抽象类是面向对象编程中的一个概念，它是一个不能被实例化的类，只能被用作其他类的基类或父类。抽象类用于定义一组相关的方法，但这些方法没有具体的实现，而是由其子类来实现。

抽象类通常包含抽象方法（也称为纯虚方法），这些方法没有具体的实现代码，只是定义了方法的名称、参数列表和返回类型。子类必须实现这些抽象方法，否则子类也必须声明为抽象类。抽象方法的存在使得抽象类本身无法被实例化，因为它包含了未实现的方法。

抽象类可以包含非抽象的方法和属性，这些方法和属性可以有具体的实现代码。子类可以继承这些非抽象方法和属性，并且可以根据需要进行覆盖或扩展。

抽象类的主要目的是为了提供一种通用的基类，定义了一组共享的方法和属性，但具体的实现由子类来完成。通过使用抽象类，可以实现某种程度的代码重用和统一的接口定义。

在Java中，抽象类是通过使用关键字abstract来声明和定义的。下面是Java中定义抽象类的语法：

abstract class AbstractClassName {
    // 可包含抽象方法和非抽象方法、属性等成员
    // 抽象方法的声明
    // 非抽象方法的实现
    // 属性的定义
}

1.2 抽象类的特点

graph LR
A(抽象类特点)
B(抽象类不能被实例化)
C(抽象类可以包含抽象方法)
D(子类必须实现抽象方法)
E(抽象类可以包含非抽象方法和属性)
F(抽象类可以拥有构造方法)
G(子类继承抽象类)

A ---> B
A ---> C
A ---> D
A ---> E
A ---> F
A ---> G

style B fill:#FFC0CB,stroke:#FFC0CB,stroke-width:2px
style C fill:#FFA07A,stroke:#FFA07A,stroke-width:2px
style D fill:#FFFFE0,stroke:#FFFFE0,stroke-width:2px
style E fill:#98FB98,stroke:#98FB98,stroke-width:2px
style F fill:#ADD8E6,stroke:#ADD8E6,stroke-width:2px
style G fill:#00FFFF,stroke:#00FFFF,stroke-width:2px

抽象类不能被实例化：抽象类只能被用作其他类的基类或父类，不能直接创建对象。

抽象类可以包含抽象方法：抽象方法没有具体的实现代码，只有方法的声明，需要在子类中进行实现。

子类必须实现抽象方法：如果一个类继承了抽象类，那么它必须实现抽象类中所有的抽象方法，除非该子类也声明为抽象类。

抽象类可以包含非抽象方法和属性：抽象类可以定义具体的方法和属性，供子类直接继承和使用。

抽象类可以拥有构造方法：抽象类可以有构造方法，用于初始化抽象类的成员。

子类继承抽象类：子类可以通过使用关键字extends来继承抽象类，并实现抽象类中的抽象方法。

1.3 抽象类的案例

首先定义一个Animal是一个抽象类，包含了一个抽象方法makeSound()和一个非抽象方法getName()

/**
 * 抽象类:动物
 *
 * @author bamboo panda
 * @version 1.0
 * @date 2023/10/20 11:53
 */
public abstract class Animal {

    /**
     * 变量
     */
    private String name;

    /**
     * 构造函数
     *
     * @param name 名称
     */
    public Animal(String name) {
        this.name = name;
    }

    /**
     * 抽象方法：发出声音
     */
    public abstract void makeSound();

    /**
     * 获得名称
     *
     * @return 名称
     */
    public String getName() {
        return name;
    }

}

定义Dog类是Animal的子类，它实现了makeSound()方法并调用了父类的getName()方法

/**
 * 实现类：狗
 *
 * @author bamboo panda
 * @version 1.0
 * @date 2023/10/20 11:58
 */
public class Dog extends Animal {

    /**
     * 构造函数
     *
     * @param name
     */
    public Dog(String name) {
        super(name);
    }

    /**
     * 实现方法
     */
    @Override
    public void makeSound() {
        System.out.println(getName() + " 汪汪叫");
    }

}

写一个测试类

/**
 * 测试类
 *
 * @author bamboo panda
 * @version 1.0
 * @date 2023/10/20 12:01
 */
public class Test {

    public static void main(String[] args) {
        // 使用多态的方式来创建阿黄
        Animal animal = new Dog("阿黄");
        // 调用发出声音方法
        animal.makeSound();
    }

}

我们分析一下这个测试方法

Animal animal = new Dog("阿黄");：创建了一个Dog对象，并将其赋值给类型为Animal的变量animal。这是多态的一种表现形式，即将子类对象赋给父类类型的变量。

new Dog("阿黄")：创建了一个Dog对象，使用了Dog类的构造方法，并传入参数"阿黄"来初始化Dog对象的名称。

Animal animal =：将Dog对象赋值给类型为Animal的变量animal。这是由于子类对象可以赋值给父类类型的变量，这样做的好处是可以通过父类类型的变量来访问子类对象的方法和属性。

animal.makeSound();：调用animal变量所引用对象的makeSound()方法。由于animal的类型是Animal，而Animal类声明了makeSound()方法为抽象方法，因此实际上会调用Dog类中实现的makeSound()方法。

输出结果

阿黄 汪汪叫

二、接口

2.1 接口的定义

接口是一种在面向对象编程中定义契约的方式，它定义了一组方法（包括抽象方法和默认方法）的规范，但没有具体的实现。接口提供了一种约定，用于描述类应该具有哪些方法，以及这些方法应该如何被调用。

在Java中，接口是通过使用关键字interface来声明和定义的。下面是Java中定义接口的语法：

interface InterfaceName {
    // 可包含抽象方法、默认方法、静态方法和常量等成员
    // 抽象方法的声明
    // 默认方法的实现
    // 静态方法的实现
    // 常量的定义
}

在接口的定义中，可以包含抽象方法、默认方法、静态方法和常量等成员。其中，抽象方法没有具体的实现代码，只有方法的声明；默认方法有默认的实现代码，可以在接口中直接提供默认的方法实现；

静态方法是接口的类方法，可以直接通过接口名调用；

常量是接口中的常量值，通常使用public static final修饰。

2.2 接口的特点

graph LR
A(接口的特点) 
B(接口只能包含抽象方法 默认方法 静态方法和常量等成员,不能包含实例变量和构造方法)
C(接口中的方法默认为public,且不可变更为其他访问修饰符,例如private protected)
D(类可以实现`implements`一个或多个接口,通过实现接口中的抽象方法来满足接口的契约)
E(实现接口的类必须实现接口中的所有抽象方法,否则类本身必须声明为抽象类)
F(类可以同时继承父类并实现接口,但继承只能有一个父类,而实现接口可以有多个)
G(接口之间可以进行继承,一个接口可以继承一个或多个接口,通过关键字`extends`实现)

A ---> B
A ---> C
A ---> D
A ---> E
A ---> F
A ---> G

style B fill:#FFC0CB,stroke:#FFC0CB,stroke-width:2px
style C fill:#FFA07A,stroke:#FFA07A,stroke-width:2px
style D fill:#FFFFE0,stroke:#FFFFE0,stroke-width:2px
style E fill:#98FB98,stroke:#98FB98,stroke-width:2px
style F fill:#ADD8E6,stroke:#ADD8E6,stroke-width:2px
style G fill:#00FFFF,stroke:#00FFFF,stroke-width:2px

2.3 接口的案例

Animal是一个接口，定义了一个抽象方法makeSound()和一个默认方法sleep()

/**
 * 接口:动物
 *
 * @author bamboo panda
 * @version 1.0
 * @date 2023/10/20 11:53
 */
public interface Animal {

    /**
     * 抽象方法：发出声音
     */
    void makeSound();

    /**
     * 默认方法
     */
    default void sleep() {
        System.out.println("动物睡觉了");
    }

}

Dog类实现了Animal接口，并实现了makeSound()方法。

/**
 * 实现类：狗
 *
 * @author bamboo panda
 * @version 1.0
 * @date 2023/10/20 11:58
 */
public class Dog implements Animal {

    /**
     * 实现方法
     */
    @Override
    public void makeSound() {
        System.out.println("小狗汪汪叫");
    }

}

在Test类中，我们创建了一个Dog对象，并调用了其方法。

/**
 * 测试类
 *
 * @author bamboo panda
 * @version 1.0
 * @date 2023/10/20 12:01
 */
public class Test {

    public static void main(String[] args) {
        // 使用多态的方式来创建阿黄
        Animal animal = new Dog();
        // 调用发出声音方法
        animal.makeSound();
    }

}

输出结果

小狗汪汪叫

三、抽象类和接口的区别

实际看了上面的内容，大致都分清楚了抽象类和接口的区别，下面我整体总结一下

特征	抽象类	接口
继承关系	可以被子类继承	可以被子类实现
构造方法	可以有构造方法	不能有构造方法
成员变量	可以有普通成员变量	只能有公共常量
继承和实现	一个类只能继承一个抽象类，但可以实现多个接口	一个类可以实现多个接口，但只能继承一个父类（包括抽象类）
方法声明与实现	可以包含方法声明和方法实现	只能包含方法声明，没有方法的具体实现
抽象级别	接口>抽象类>实现类
用途	主要用来抽象类别，表示具有共同特征的类的概念	主要用来抽象方法功能，表示具有共同行为的类的契约
关键字	使用关键字 `abstract` 定义	使用关键字 `interface` 定义

总结一下：

抽象类用于表示具有共同特征的类的概念，可以包含方法的声明和实现，可以有构造方法和普通成员变量，一个类只能继承一个抽象类。

接口用于表示具有共同行为的类的契约，只包含方法的声明，不能有构造方法和普通成员变量，一个类可以实现多个接口，但只能继承一个父类（包括抽象类）。

抽象类的抽象级别低于接口，抽象类可以提供更多的实现细节，而接口提供了更大的灵活性和代码的松耦合性。

抽象类使用关键字 abstract 定义，而接口使用关键字 interface 定义。

四、抽象类和接口的应用场景

graph LR
A(应用场景)

B(抽象类)
C(接口)

D(定义类的层次结构)
E(提供默认实现)
F(增加扩展性)

CD(定义规范和契约)
CE(实现多继承)
CF(提供标准化的功能)

A ---> B
A ---> C

B ---> D
B ---> E
B ---> F

C ---> CD
C ---> CE
C ---> CF

style B fill:#FFC0CB,stroke:#FFC0CB,stroke-width:2px
style C fill:#FFA07A,stroke:#FFA07A,stroke-width:2px
style D fill:#FFFFE0,stroke:#FFFFE0,stroke-width:2px
style E fill:#98FB98,stroke:#98FB98,stroke-width:2px
style F fill:#00FFFF,stroke:#00FFFF,stroke-width:2px
style CD fill:#FFFFE0,stroke:#FFFFE0,stroke-width:2px
style CE fill:#98FB98,stroke:#98FB98,stroke-width:2px
style CF fill:#00FFFF,stroke:#00FFFF,stroke-width:2px

抽象类的应用场景：

定义类的层次结构：抽象类通常用于定义类的层次结构，将共享的属性和方法放在抽象类中，子类通过继承抽象类来获得这些共享的特性。
提供默认实现：抽象类可以包含抽象方法和具体方法。具体方法可以提供默认的实现，子类可以直接继承并使用这些具体方法，减少了代码的重复性。
增加扩展性：抽象类可以定义抽象方法，子类必须实现这些抽象方法，从而强制子类具备某种行为。这样可以增加代码的可扩展性和灵活性。

接口的应用场景：

定义规范和契约：接口用于定义一组相关的操作，描述了类应该具备的能力和行为。通过实现接口，类承诺满足接口中定义的规范和契约，从而实现了代码的解耦和模块化。
实现多继承：由于Java的单继承限制，接口提供了一种实现类之间多态性的机制。一个类可以实现多个接口，从而具备多个接口定义的能力和行为，实现了类的多继承。
提供标准化的功能：接口常用于定义标准化的功能和服务，例如Java中的Comparable接口用于定义比较对象的标准，Runnable接口用于定义可执行的任务。

五、总结

抽象类和接口在面向对象编程中发挥着不同的作用，根据需求和设计目标的不同，可以选择使用其中之一或两者结合来实现代码的抽象和封装。

特别是在设计模式里面，对于接口和抽象类有大量的应用方法，可以去好好学习。

希望本文能给你带来帮助，如有错误或建议，欢迎指正和提出。