Java泛型编程：如何在自定义列表中安全调用共享方法_技术教程

本文旨在解决在java中处理泛型列表（如`arraylist`）时，如何安全地调用列表中存储的异构对象所共享的特定方法。核心方案是利用接口定义共同行为，并结合java的泛型机制，创建能够存储实现该接口的多种类型对象的列表，从而在编译时确保类型安全，避免运行时错误。

理解问题：ArrayList与异构对象方法调用

在Java中，当我们创建一个泛型列表，例如ArrayList，并尝试从列表中获取元素时，ArrayList.get(index)方法通常返回类型E的实例。然而，如果E是Object或者是一个过于宽泛的类型，而我们希望调用列表中实际存储的具体对象（如A和B）所共有的特定方法（例如getId()），就会遇到编译错误。这是因为编译器在编译时只能识别get()方法返回的类型E（或Object）所具备的方法，而无法预知其运行时实际类型是否拥有getId()方法。

例如，以下代码会引发编译错误：

public class ArrayListId extends ArrayList {
    // ... 构造函数 ...

    public void doSomething(){
        // some code
        // 编译错误：Object类型没有getId()方法
        String id = this.get(0).getId();
        // some code
    }
}

即使我们知道列表中的所有对象都包含getId()方法，编译器也无法在没有明确类型信息的情况下允许这种调用。

解决方案一：利用接口定义共同行为（推荐）

解决此问题的最优雅和推荐的方式是定义一个接口来声明所有相关类（如A和B）共同拥有的方法。然后，让这些类实现该接口。

1. 定义共享接口

首先，创建一个接口，其中包含所有你希望在列表元素上调用的共享方法。

interface CommonIdentifiable {
    String getId();
}

2. 实现接口

让所有需要存储在列表中的类实现这个新定义的接口。

class ClassA implements CommonIdentifiable {
    private String id;

    public ClassA(String id) {
        this.id = id;
    }

    @Override
    public String getId() {
        return "A_" + id;
    }

    // 其他方法...
}

class ClassB implements CommonIdentifiable {
    private String id;

    public ClassB(String id) {
        this.id = id;
    }

    @Override
    public String getId() {
        return "B_" + id;
    }

    // 其他方法...
}

3. 使用接口作为泛型类型

现在，你可以创建一个以CommonIdentifiable作为泛型类型参数的ArrayList。这个列表可以同时存储ClassA和ClassB的实例，因为它们都实现了CommonIdentifiable接口。

import java.util.ArrayList;
import java.util.List;

public class ListProcessor {

    public static void main(String[] args) {
        List mixedList = new ArrayList<>();
        mixedList.add(new ClassA("001"));
        mixedList.add(new ClassB("002"));
        mixedList.add(new ClassA("003"));

        // 现在可以安全地调用getId()方法
        for (CommonIdentifiable item : mixedList) {
            System.out.println("Item ID: " + item.getId());
        }

        // 或者通过索引访问
        System.out.println("First item ID: " + mixedList.get(0).getId());

        doSomethingWithList(mixedList);
    }

    public static void doSomethingWithList(List list) {
        // some code
        if (!list.isEmpty()) {
            String id = list.get(0).getId(); // 编译通过，类型安全
            System.out.println("Processed first item ID in doSomething: " + id);
        }
        // some other code
    }
}

优点：

类型安全： 编译器在编译时就能确保所有列表元素都具有getId()方法。
多态性： 允许在同一个列表中存储不同类型的对象，只要它们实现相同的接口。
解耦： 列表操作与具体实现类解耦，提高了代码的灵活性和可维护性。
无需继承ArrayList： 在大多数情况下，你不需要为了这个目的而扩展ArrayList。直接使用List即可。

解决方案二：扩展ArrayList并使用泛型约束（如果必须）

尽管通常不建议仅仅为了调用共同方法而扩展ArrayList，但在某些特定场景下，如果你确实需要创建一个自定义的ArrayList子类，并希望在该子类内部调用元素的共同方法，你可以使用泛型约束。

1. 定义泛型约束

在扩展ArrayList时，你需要为泛型类型参数E添加一个约束，指定E必须是CommonIdentifiable接口的子类型。

import java.util.ArrayList;
import java.util.Collection;

// 假设 CommonIdentifiable 接口和 ClassA, ClassB 已定义如上

public class CustomArrayListId extends ArrayList {

    public CustomArrayListId(@NonNull Collection c) {
        super(c);
    }

    public CustomArrayListId() {
        super();
    }

    public void processFirstItemId(){
        if (!this.isEmpty()) {
            // 现在可以安全地调用getId()方法，因为E被约束为CommonIdentifiable
            String id = this.get(0).getId();
            System.out.println("Processed first item ID in custom list: " + id);
        } else {
            System.out.println("Custom list is empty.");
        }
    }

    // 其他自定义方法...
}

2. 使用自定义列表

现在，你可以创建CustomArrayListId的实例，但其泛型类型参数必须是CommonIdentifiable或其实现类。

import java.util.Arrays;

public class CustomListUsage {
    public static void main(String[] args) {
        // 可以传入CommonIdentifiable的实现类
        CustomArrayListId listA = new CustomArrayListId<>();
        listA.add(new ClassA("X01"));
        listA.add(new ClassA("X02"));
        listA.add(new ClassA("X03"));
        listA.processFirstItemId(); // 输出：Processed first item ID in custom list: A_X01

        CustomArrayListId listB = new CustomArrayListId<>();
        listB.add(new ClassB("Y01"));
        listB.processFirstItemId(); // 输出：Processed first item ID in custom list: B_Y01

        // 也可以直接使用CommonIdentifiable作为泛型参数
        CustomArrayListId mixedCustomList = new CustomArrayListId<>(
                Arrays.asList(new ClassA("Z01"), new ClassB("Z02"))
        );
        mixedCustomList.processFirstItemId(); // 输出：Processed first item ID in custom list: A_Z01
    }
}

注意事项：

继承的局限性： 继承ArrayList可能会带来一些问题，例如，如果ArrayList的内部实现发生变化，你的子类可能会受到影响。此外，ArrayList的某些方法可能不是为子类化而设计的。
优先考虑组合： 在大多数情况下，如果你需要扩展ArrayList的功能，更推荐使用组合（Composition）而不是继承（Inheritance）。这意味着你可以创建一个包含ArrayList实例的类，并在新类中封装ArrayList的功能，同时添加自己的特定行为。