Java 基础 （八）抽象类和接口

Java接口核心知识点与实战总结（学习笔记）

在Java面向对象编程体系中，接口是实现抽象、多态和解耦的核心工具，它解决了Java单继承的局限性，同时为不同类定义了统一的行为规范。本文结合课堂笔记和排序实战代码，系统梳理接口的核心特性、与抽象类的本质区别、访问修饰符规则，并通过通用排序案例深入理解接口的实际应用价值。

一、接口的核心基础特性

接口本质上是一种行为契约，它只定义类应该具备的能力，不提供具体实现。以下是接口的7条核心基础特性：

1. 接口使用interface关键字定义

   接口是完全抽象的类型，与类的定义方式不同，示例：

   // 定义Animal接口
   public interface Animal {}
   // 接口之间可以继承（多继承）
   public interface Person extends Animal {}

2. 接口中的成员变量默认是public static final

   接口中只能定义常量，不能定义实例变量，且必须在定义时初始化。即使不写这三个修饰符，编译器也会自动添加。

3. 接口中的抽象方法默认是public abstract

   Java 7及以前，接口中只能存在公共抽象方法，不能有方法体。实现类必须重写所有抽象方法。

4. 接口没有构造方法，不能直接实例化

   构造方法用于创建对象，接口无法通过new关键字实例化，但可以声明接口类型的变量，指向其实现类的对象（多态的核心体现）。

5. 实现接口的类必须实现所有抽象方法，否则为抽象类

   如果一个类实现了接口但未实现全部抽象方法，那么该类必须声明为abstract，由其子类完成剩余方法的实现。

6. 接口之间支持多继承

   与类的单继承不同，一个接口可以同时继承多个父接口，使用extends关键字，多个接口之间用逗号分隔。

7. 接口与实现类之间存在多态性

   接口类型的变量可以引用任何实现了该接口的类的对象，这使得我们可以编写通用的代码，处理不同的实现类。

补充：Java 8+接口新特性

随着Java版本的升级，接口的能力得到了扩展：

• 默认方法（default）：接口中可以定义有方法体的默认方法，实现类可以直接继承或重写，解决了接口升级时的兼容性问题。
• 静态方法（static）：接口中可以定义静态方法，通过接口名直接调用。
• Java 9新增 ：私有方法（private）和私有静态方法，用于接口内部的代码复用，避免代码冗余。

二、接口与抽象类的对比

抽象类和接口都是实现抽象的手段，但它们的设计目的和使用场景有本质区别：

特性	抽象类	接口
继承关系	单继承（一个类只能继承一个抽象类）	多实现（一个类可以实现多个接口）
成员变量	支持任意访问修饰符，可以有实例变量和静态变量	只能是public static final常量
方法	可以有抽象方法、实例方法、静态方法和构造方法	Java 7：仅public abstract抽象方法 Java 8+：新增default默认方法和static静态方法 Java 9+：新增private私有方法
构造方法	有构造方法，用于子类初始化	无构造方法，不能实例化
设计目的	对类的共性进行抽象，提取公用属性和方法，体现"is-a"关系	对类的行为进行规范和补充，定义类应该具备的能力，体现"like-a"关系
使用场景	多个类有共同的属性和方法时，提取为抽象类	多个类需要遵循相同的行为规范，但没有共同父类时，使用接口

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

三、Java访问修饰符详解

访问修饰符控制了类、方法和变量的可见范围，是实现封装的核心手段。以下是四种访问修饰符的权限对比：

访问修饰符	本类	同包子类	同包非子类	不同包子类	不同包非子类
private	√	×	×	×	×
default（不写修饰符）	√	√	√	×	×
protected	√	√	√	√	×
public	√	√	√	√	√

• private：最严格的权限，仅在本类内部可见，用于隐藏内部实现细节。
• default：包访问权限，仅在同一个包内可见，是默认的访问权限。
• protected：受保护权限，同包内可见，不同包的子类也可以访问。
• public：公共权限，所有地方都可以访问，用于对外暴露API。

四、实战案例：利用Comparable接口实现通用排序

Java提供的Arrays.sort()方法可以直接排序基本类型数组，但对于自定义对象数组，需要我们定义排序规则。Comparable接口就是Java提供的用于定义对象比较规则的标准接口。

1. 案例需求

实现一个通用的快速排序工具类，能够对任何实现了Comparable接口的对象数组进行排序。我们将通过Cat和Dog两个自定义类来测试不同的排序规则。

2. 代码实现与解析

（1）自定义类实现Comparable接口

• Cat类：按年龄升序排序

  public class Cat implements Comparable<Cat> {
      public Integer age;
      public Integer height;
      
      public Cat(Integer age, Integer height) {
          this.age = age;
          this.height = height;
      }
      
      // 重写compareTo方法，定义比较规则
      @Override
      public int compareTo(Cat o) {
          // 升序：当前对象属性 - 参数对象属性
          return this.age - o.age;
      }
  }

• Dog类：按身高降序排序

  public class Dog implements Comparable<Dog> {
      public Integer age;
      public String name;
      public Integer height;
      
      public Dog(String name, Integer age, Integer height) {
          this.name = name;
          this.age = age;
          this.height = height;
      }
      
      @Override
      public String toString() {
          return "Dog{" + "age=" + age + ", name=" + name + ", height=" + height + '}';
      }
      
      @Override
      public int compareTo(Dog object) {
          // 降序：参数对象属性 - 当前对象属性
          return object.height - this.height;
      }
  }

  compareTo方法返回值规则：

  • 返回负数：当前对象小于参数对象，排在前面
  • 返回0：当前对象等于参数对象
  • 返回正数：当前对象大于参数对象，排在后面

（2）通用快速排序工具类MyArrays

public class MyArrays {
    // 对外暴露的排序方法
    public static void sort(Object[] objects) {
        quickSort(objects, 0, objects.length - 1);
    }
    
    // 快速排序核心逻辑
    private static void quickSort(Object[] objects, int left, int right) {
        // 强转为Comparable数组：利用多态，所有实现了Comparable的对象都可以比较
        Comparable[] arr = (Comparable[]) objects;
        
        // 递归终止条件
        if (left >= right) {
            return;
        }
        
        Comparable base = arr[left]; // 基准元素
        int i = left;
        int j = right;
        
        while (i < j) {
            // 从右往左找第一个比基准大的元素
            while (arr[j].compareTo(base) <= 0 && i < j) {
                j--;
            }
            // 从左往右找第一个比基准小的元素
            while (arr[i].compareTo(base) >= 0 && i < j) {
                i++;
            }
            // 交换元素
            Comparable temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        
        // 将基准元素放到正确的位置
        arr[left] = arr[i];
        arr[i] = base;
        
        // 递归排序左右子数组
        quickSort(objects, left, i - 1);
        quickSort(objects, i + 1, right);
    }
}

这里的关键是将Object[]强转为Comparable[]，这利用了接口的多态性------只要传入的数组元素实现了Comparable接口，就可以调用compareTo方法进行比较。

（3）测试类Main

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // 测试基本类型数组排序（JDK自带方法）
        int[] arr = new int[]{1, 2, 5, 4, 3};
        Arrays.sort(arr);
        System.out.println("基本类型数组排序结果：" + Arrays.toString(arr));
        // 输出：[1, 2, 3, 4, 5]
        
        // 测试自定义Dog对象数组排序
        Dog dog1 = new Dog("旺财", 1, 600);
        Dog dog2 = new Dog("旺财", 2, 500);
        Dog dog3 = new Dog("旺财", 3, 800);
        Dog dog4 = new Dog("旺财", 3, 200);
        Dog[] dogs = new Dog[]{dog1, dog2, dog3, dog4};
        
        MyArrays.sort(dogs);
        System.out.println("Dog数组按身高降序排序结果：" + Arrays.toString(dogs));
        // 输出：[Dog{age=3, name=旺财, height=800}, Dog{age=1, name=旺财, height=600}, Dog{age=2, name=旺财, height=500}, Dog{age=3, name=旺财, height=200}]
    }
}

3. 案例总结

通过实现Comparable接口，我们为不同的自定义类定义了各自的排序规则。而MyArrays类的sort方法完全不依赖于具体的实现类，只依赖于Comparable接口，这使得它可以对任何实现了该接口的对象数组进行排序，极大地提高了代码的复用性和通用性。这正是接口的核心价值：定义规范，解耦实现。

五、总结

接口是Java面向对象编程的基石之一，它通过定义行为契约，实现了代码的解耦、复用和多态。在实际开发中，我们应该遵循以下原则：

1. 优先使用接口定义行为规范，而不是抽象类。
2. 一个接口只定义一个单一的功能（单一职责原则）。
3. 合理使用访问修饰符，提高代码的封装性。
4. 利用接口的多态性，编写通用的代码逻辑。

掌握接口的特性和使用方法，是写出高质量、可扩展Java代码的必备技能。通过本次排序案例的练习，我们不仅加深了对接口的理解，也学会了如何利用Java提供的标准接口解决实际问题。