本文旨在解决在处理包含不同类型对象列表的实体时，如何避免重复代码的问题。通过引入接口 HasOrden，定义了所有需要排序的对象都必须实现的 getOrden 和 setOrden 方法。然后，我们创建了一个泛型方法 sortOrden，它可以对任何实现了 HasOrden 接口的对象列表进行排序，从而消除了针对不同类型编写重复代码的需求。
在软件开发中，经常会遇到需要对不同类型的对象进行类似操作的情况。例如，一个实体可能包含多个对象列表，这些对象虽然类型不同，但都具有相同的属性，比如排序字段。如果针对每种类型都编写重复的代码，会导致代码冗余、难以维护。本文将介绍如何使用 Java 接口和泛型来创建更通用的代码，以处理这种情况。
1. 定义接口
首先，我们需要定义一个接口，该接口包含所有类型都需要实现的公共方法。在本例中，所有对象都需要具有 getOrden() 和 setOrden(int i) 方法，因此我们可以定义一个名为 HasOrden 的接口：
interface HasOrden {
int getOrden();
void setOrden(int i);
}这个接口定义了获取和设置对象排序属性的方法。任何需要进行排序的对象都必须实现这个接口。
2. 实现接口
接下来，我们需要让需要排序的类实现 HasOrden 接口。例如，假设我们有两个类 Experiencia 和 Educacion，它们都具有 orden 属性。
class Experiencia implements HasOrden {
private final String name;
int orden;
public Experiencia(String name) {
this.name = name;
}
@Override
public int getOrden() {
return orden;
}
@Override
public void setOrden(int i) {
orden = i;
}
public String toString() {
return name;
}
}
class Educacion implements HasOrden {
private final String school;
int orden;
public Educacion(String school) {
this.school = school;
}
@Override
public int getOrden() {
return orden;
}
@Override
public void setOrden(int i) {
orden = i;
}
public String toString() {
return school;
}
}现在，Experiencia 和 Educacion 类都实现了 HasOrden 接口，这意味着它们都具有 getOrden() 和 setOrden(int i) 方法。
3. 创建泛型方法
现在我们可以创建一个泛型方法，该方法可以对任何实现了 HasOrden 接口的对象列表进行排序。
import java.util.List;
class Eg {
static void sortOrden(List<? extends HasOrden> l, List<Integer> order) {
if (l.size() != order.size()) {
throw new RuntimeException("length mismatch");
}
for (int i = 0; i < l.size(); i++) {
l.get(i).setOrden(order.get(i));
}
l.sort((it1,it2)-> Integer.compare(it1.getOrden(), it2.getOrden()));
}
public static void main(String[] args) {
List<Experiencia> items = new ArrayList<>(List.of(new Experiencia("a"), new Experiencia("b")));
List<Integer> order = List.of(2,1);
sortOrden(items, order);
System.out.println(items);
}
}sortOrden 方法接受两个参数：一个实现了 HasOrden 接口的对象列表和一个整数列表，该整数列表表示每个对象的排序顺序。该方法首先检查列表的大小是否匹配，然后遍历列表，设置每个对象的 orden 属性，最后对列表进行排序。
4. 使用泛型方法
现在我们可以使用 sortOrden 方法来对 Experiencia 和 Educacion 列表进行排序，而无需编写重复的代码。
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Experiencia> experiencias = new ArrayList<>();
experiencias.add(new Experiencia("Software Engineer"));
experiencias.add(new Experiencia("Data Scientist"));
List<Educacion> educaciones = new ArrayList<>();
educaciones.add(new Educacion("Harvard University"));
educaciones.add(new Educacion("Stanford University"));
List<Integer> experienciaOrder = List.of(1, 0);
List<Integer> educacionOrder = List.of(0, 1);
Eg.sortOrden(experiencias, experienciaOrder);
Eg.sortOrden(educaciones, educacionOrder);
System.out.println("Sorted Experiencias: " + experiencias);
System.out.println("Sorted Educaciones: " + educaciones);
}
}总结
通过使用接口和泛型，我们可以创建更通用的代码，以处理不同类型的对象。这可以减少代码冗余，提高代码的可维护性。
注意事项：
- 确保所有需要排序的对象都实现了 HasOrden 接口。
- 在调用 sortOrden 方法时，确保传递的列表类型是正确的。
- 如果需要对列表进行更复杂的排序，可以修改 sortOrden 方法中的排序逻辑。
通过以上步骤，你就可以为不同类型的对象创建泛型代码，避免重复编写相似功能的代码，提高代码的复用性和可维护性。
