接口和抽象类的区别与Sort方法

文章目录 前言一、接口（Interface）1.特点 二、抽象类（Abstract Class）1.特点2.类的实现 三、接口和抽象类的区别1. 定义与修饰符2. 方法的实现3. 构造器4. 成员变量5. 继承与实现6. 与 `final` 和 `static` 的关系7. 实例化 四、Sort 方法：基于 Comparable 接口的自定义排序1.实现Comparable接口进行排序2.自定义快速排序 总结

---

前言

在面向对象编程（OOP）中，接口（Interface）和抽象类（Abstract Class）是两个非常重要的概念，它们用于定义类的行为并促进代码的复用和模块化。本文将重点讨论接口和抽象类的区别，并通过一个示例展示如何在Java中实现这些概念，以及如何在博客系统中应用sort方法。

---

一、接口（Interface） 1.特点 接口使用interface关键字定义。接口中的所有成员变量默认是public static final修饰的，即公有的静态常量。接口中的所有方法默认是public abstract修饰的，即抽象方法。接口不能被实例化，因为没有构造器。接口中的方法全部是抽象方法，与抽象类不同。接口可以互相继承，实现代码的复用。

示例

package 接口; public interface Eat { void eat(); } public interface Run { void run(); } 二、抽象类（Abstract Class） 1.特点 由abstract修饰的类叫做抽象类，由abstract修饰的方法叫做抽象方法。abstract修饰的抽象方法，不在抽象类当中去实现，更多的作为子类必须实现的方法的定义。抽象类中可以有抽象方法（abstract修饰），也可以有普通方法。抽象类不能被实例化，因为没有构造器。final和abstract不能同时使用，因为final表示类不能被继承，而abstract表示类必须被继承。抽象方法不能使用static，因为static是针对类层次，抽象方法是针对对象层次的，所以不能一起使用。子类继承抽象类后，如果不想实现抽象类中的抽象方法，那么子类必须也是抽象类。抽象类一定是父类。

示例

package 接口; public abstract class Animal { public abstract void jump(); public abstract void drunk(); public void eat() { System.out.println("动物在吃东西..."); } } 2.类的实现

一个类可以实现多个接口，但只能继承一个抽象类。以下是Cow类的实现，它继承了Animal抽象类并实现了Eat和Run接口。

package 接口; public class Cow extends Animal 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("牛在飞..."); } } 三、接口和抽象类的区别 1. 定义与修饰符 抽象类：使用 abstract 修饰的类称为抽象类。抽象类中可以包含抽象方法（使用 abstract 修饰的方法）和普通方法。接口：使用 interface 关键字定义。接口中的方法默认是 public abstract 修饰的抽象方法，接口中的成员变量默认是 public static final 修饰的常量。 2. 方法的实现 抽象类：抽象类中可以包含抽象方法（没有方法体）和普通方法（有方法体）。子类继承抽象类时，必须实现所有的抽象方法，除非子类也是抽象类。接口：接口中的所有方法默认都是抽象方法，没有方法体。实现接口的类必须实现接口中的所有方法，除非该类是抽象类。 3. 构造器 抽象类：抽象类可以有构造器，但不能被实例化。构造器主要用于子类实例化时调用。接口：接口没有构造器，不能被实例化。 4. 成员变量 抽象类：抽象类中可以定义普通成员变量和静态变量。接口：接口中的成员变量默认是 public static final 修饰的常量，且必须初始化。 5. 继承与实现 抽象类：一个类只能继承一个抽象类（单继承），子类继承抽象类后，可以选择实现抽象方法或继续将子类声明为抽象类。接口：一个类可以实现多个接口（多实现），接口之间也可以互相继承（多继承）。 6. 与 final 和 static 的关系 抽象类：抽象方法不能使用 static 修饰，因为抽象方法是针对对象层次的，而 static 方法是针对类层次的。final 不能与 abstract 同时使用，因为 final 修饰的类不能被继承，final 修饰的方法不能被重写。接口：接口中的方法不能使用 final 修饰，因为接口的方法必须由实现类来实现。接口中的方法默认是 public abstract 的，不能是 static 的。 7. 实例化 抽象类：抽象类不能被实例化，只能通过子类来实例化。接口：接口不能被实例化，只能通过实现类来实例化。 四、Sort 方法：基于 Comparable 接口的自定义排序 1.实现Comparable接口进行排序

以下是一个完整的代码示例，展示了如何通过实现 Comparable 接口对 Person 对象进行排序

package 接口; public class Person implements Comparable<Person> { public String name; public int age; public double height; public Person(String name, int age, double height) { this.name = name; this.age = age; this.height = height; } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + ", height=" + height + '}'; } @Override public int compareTo(Person o) { // 按 age 从小到大排序 // return this.age - o.age; // 按 age 从大到小排序 // return o.age - this.age; // 按 height 从小到大排序 return (int) (this.height - o.height); } }

在 Person 类中，我们实现了 Comparable 接口，并重写了 compareTo 方法。通过修改 compareTo 方法的返回值，可以实现不同的排序规则：

按 age 从小到大排序：return this.age - o.age;按 age 从大到小排序：return o.age - this.age;按 height 从小到大排序：return (int) (this.height - o.height); 2.自定义快速排序

虽然Java标准库提供了Arrays.sort()方法，但为了深入理解排序机制，我们可以自己实现一个排序算法，比如快速排序。

package 接口; public class Arrays2 { /** * 对实现了 Comparable 接口的数组进行排序 * * @param o 待排序的数组 */ public static void sort(Comparable[] o) { quickSort(o, 0, o.length - 1); } /** * 快速排序算法 * * @param arr 待排序的数组 * @param left 左边界 * @param right 右边界 */ 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] pareTo(base) >= 0 && i < j) { j--; } // 从左向右找大于基准值的元素 while (arr[i] pareTo(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); } }

在 Test类中，我们创建了一个 Person 数组，并分别使用 Arrays.sort 和自定义的 Arrays2.sort 进行排序。通过输出结果，可以验证排序的正确性。

package 接口; 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 数组 Person[] arrPersons = new Person[]{p1, p2, p3, p4}; // 使用 Arrays.sort 进行排序 Arrays.sort(arrPersons); System.out.println("Arrays.sort 排序结果：" + Arrays.toString(arrPersons)); // 使用自定义的 Arrays2.sort 进行排序 Arrays2.sort(arrPersons); System.out.println("Arrays2.sort 排序结果：" + Arrays.toString(arrPersons)); } }

结果

Arrays.sort 排序结果：[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}] Arrays2.sort 排序结果：[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}]

---

总结

接口和抽象类在Java中扮演着不同的角色，用于实现代码复用和模块化设计。通过理解它们的特性和使用场景，开发者可以更加灵活地设计系统，提高代码的可维护性和可扩展性。 通过实现 Comparable 接口，我们可以轻松地为自定义类定义排序规则。同时，通过自定义排序算法（如快速排序），我们可以更深入地理解排序的原理和实现方式。 希望本文能帮助你更好地理解 Java 中的排序机制！如果有任何问题，欢迎留言讨论。