Java 中的抽象类与接口：深入解析与实践_java 接口抽象类抽象方法类继承实现描述和使用场景-优快云博客

本文链接：https://blog.youkuaiyun.com/2403_87729201/article/details/145682599

在 Java 编程中，抽象类和接口是面向对象编程的重要概念，它们都用于实现代码的抽象和复用，但它们之间存在一些关键的区别。本文将结合实际代码案例，详细讲解抽象类和接口的特点、区别，以及如何在实际开发中选择使用它们。

一、抽象类与接口的基本概念

1. 抽象类

抽象类是使用 abstract 关键字修饰的类，它可以包含普通方法、抽象方法、成员变量以及构造方法。抽象类的主要特点是不能被实例化，但可以作为父类被继承。子类继承抽象类后，必须实现父类中的所有抽象方法，否则子类也必须声明为抽象类。

2. 接口

接口是使用 interface 关键字定义的，它是一种更高级的抽象形式。接口中只能包含抽象方法和常量（默认是 public static final 修饰的），不能包含普通方法或成员变量。接口不能被实例化，但可以被实现（使用 implements 关键字）。一个类可以实现多个接口，从而实现多继承的效果。

二、抽象类与接口的区别

1. 定义方式

抽象类：通过 abstract class 关键字定义。
接口：通过 interface 关键字定义。

2. 成员变量

抽象类：可以包含普通成员变量和静态变量。
接口：只能包含 public static final 修饰的常量。

3. 方法

抽象类：可以包含普通方法、抽象方法以及静态方法。
接口：接口中的所有方法默认都是public abstract修饰的(抽象方法)。

4. 构造方法

抽象类：可以有构造方法，用于初始化子类对象。
接口：没有构造方法，不能被实例化。

5. 继承与实现

抽象类：使用 extends 关键字继承，一个子类只能继承一个抽象类（单继承）。
接口：使用 implements 关键字实现，一个类可以实现多个接口（多继承）。

6. 使用场景

抽象类：适用于类与类之间有明显的继承关系，并且需要共享代码的场景。
接口：适用于定义一组行为规范，供多个类实现的场景，强调的是功能的扩展。

三、代码案例分析

1. 抽象类的使用

定义一个抽象类 Anminal：

public abstract class Anminal {
    public abstract void jump();
    public abstract void drunk();
}

该类中包含两个抽象方法 jump() 和 drunk()，没有具体实现。 Cow 类继承了 Anminal 并实现了这两个抽象方法：

public class Cow extends Anminal implements Eat, Run {
    @Override
    public void jump() {
        System.out.println("牛在跳。。。。");
    }

    @Override
    public void drunk() {
        System.out.println("牛在喝水。。。。");
    }

    @Override
    public void eat() {
        System.out.println("牛在吃草。。。。。。");
    }

    @Override
    public void run() {
        System.out.println("牛在跑。。。。");
    }

    public void flay() {
        System.out.println("牛在飞。。。。。");
    }
}

通过继承抽象类，Cow 类实现了 Anminal 的行为规范，同时还可以扩展其他功能（如 flay() 方法）。

2. 接口的使用

分别定义两个接口 Run 和 Eat：

public interface Run {
    void run();
}

public interface Eat {
    void eat();
}

Cow 类实现了这两个接口：

public class Cow extends Anminal implements Eat, Run {
    // 实现接口中的方法
    @Override
    public void eat() {
        System.out.println("牛在吃草。。。。。。");
    }

    @Override
    public void run() {
        System.out.println("牛在跑。。。。");
    }
}

通过实现接口，Cow 类具备了 Run 和 Eat 的行为规范，体现了接口的多继承特性。

3. 接口与抽象类的结合

在文件 8 中，Cow 类既继承了抽象类 Anminal，又实现了接口 Eat 和 Run，这种设计方式结合了抽象类和接口的优点：

抽象类：提供了通用的行为规范（如 jump() 和 drunk() 方法）。
接口：扩展了额外的功能（如 eat() 和 run() 方法）。

4. 自定义排序方法

我们重写了 Arrays.sort() 方法，使用快速排序算法对数组进行排序：

package com.qcby;

public class Arrays2 {
    /**
     * 对数组进行排序
     *
     * @param o 需要排序的数组
     */
    public static void sort(Comparable[] o) {
        quickSort(o, 0, o.length - 1);
    }

    public static void quickSort(Comparable[] arr, int left, int right) {
        if (left > right) {
            return;
        }
        int i = left;
        int j = right;
        // 定义基准值
        Comparable base = arr[left];

        while (i != j) {
            while (arr[j].compareTo(base) >= 0 && i < j) {
                j--;
            }
            while (arr[i].compareTo(base) <= 0 && i < j) {
                i++;
            }
            // 交换元素
            Comparable temp = arr[j];
            arr[j] = arr[i];
            arr[i] = temp;
        }

        // 将基准值放到中间位置
        arr[left] = arr[i];
        arr[i] = base;

        // 递归排序左右两部分
        quickSort(arr, left, i - 1);
        quickSort(arr, i + 1, right);
    }
}

重写 `sort` 方法的思路

定义方法签名：我们定义了一个静态方法 sort，接收一个 Comparable[] 类型的数组作为参数。Comparable 是 Java 中的一个接口，用于定义对象的排序规则。
调用快速排序算法：在 sort 方法中，我们调用了 quickSort 方法，传入数组以及左右边界。
实现快速排序：
- 基准值：选择数组的第一个元素作为基准值 base。
- 分区操作：通过两个指针 i 和 j，分别从数组的两端向中间移动，找到需要交换的元素。
- 交换元素：将 i 和 j 指向的元素交换位置。
- 递归排序：将数组分为两部分，分别对左右两部分递归调用 quickSort 方法。

测试代码

测试代码验证自定义排序方法的正确性：

package com.qcby;

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person("小黑", 18, 189.5);
        Person p2 = new Person("小白", 22, 185.5);
        Person p3 = new Person("小虎", 20, 184.5);
        Person p4 = new Person("小何", 24, 185.5);

        Person[] arrPersons = new Person[]{p1, p2, p3, p4};
        // 使用自定义的 sort 方法
        Arrays2.sort(arrPersons);
        System.out.println(Arrays.toString(arrPersons));
    }
}

运行结果将按照 Person 对象的身高从小到大排序输出：

[Person{name='小虎', age=20, height=184.5}, Person{name='小白', age=22, height=185.5}, Person{name='小何', age=24, height=185.5}, Person{name='小黑', age=18, height=189.5}]