Java泛型实战：解析带继承和接口的复杂示例

2024-04-02 06:46:03

Java泛型：带继承和接口的复杂示例解析

在Java开发中，泛型是一个强有力的特性，它允许我们编写可重用的代码，而不会牺牲类型安全。然而，当涉及到继承和接口时，泛型可能会变得有些复杂。本文将深入解析一个涉及泛型、继承和接口的复杂示例，并逐步解决其中的编译错误。

问题

在这个示例中，我们定义了一个接口ComparatorBase，它包含一个isSame方法，用于比较两个对象并返回差异。我们还定义了一个基类BaseObjectData，它实现了ComparatorBase接口，并包含getObjectValue1和getObjectValue2方法。此外，我们有一个继承类InheritLevel1Data，它扩展了BaseObjectData并包含了getObjectValue3方法。

我们还提供了一个RunnerTest类，它创建了两个BaseObjectData列表，并使用isSame方法计算它们的差异。然而，这个示例存在几个编译错误，阻碍了它的正常运行。

编译错误

在BaseObjectData.isSame方法中：otherObject.getId()和otherObject.getObjectValue1()是未知的方法。
在InheritLevel1Data.isSame方法中：otherObject.getObjectValue3()是未知的方法。

解决编译错误

BaseObjectData.isSame方法：

ComparatorBase接口中的isSame方法没有指定任何参数类型，因此编译器不知道otherObject的类型。为了解决这个问题，我们需要将泛型类型参数T指定为isSame方法的参数类型。修改后的代码如下：
```
@Override
public List<Difference> isSame(T otherObject) {
    // ... 代码同上 ...
}
```
InheritLevel1Data.isSame方法：

由于InheritLevel1Data继承了BaseObjectData的isSame方法，因此它也需要将泛型类型参数T指定为isSame方法的参数类型。修改后的代码如下：
```
@Override
public List<Difference> isSame(T otherObject) {
    // ... 代码同上 ...
}
```

完整的解决方案

以下是修改后的完整解决方案：

BaseObjectData.java

@NoArgsConstructor
@AllArgsConstructor
@Setter
@Getter
@Builder
public class BaseObjectData<T> implements ComparatorBase<T> {
    private String id;
    private String objectValue1;
    private String objectValue2;

    @Override
    public List<Difference> isSame(T otherObject) {
        List<Difference> differences = new ArrayList<>();
        if( ! getObjectValue1().equals( otherObject.getObjectValue1())) {
            differences.add( new Difference( getId(), getObjectValue1(), otherObject.getObjectValue1()));
        }
        if( ! getObjectValue2().equals( otherObject.getObjectValue2())) {
            differences.add( new Difference( getId(), getObjectValue2(), otherObject.getObjectValue2()));
        }
        return differences;
    }

    T findMatchingObject( List<T> otherObjects) {
        for( T object: otherObjects) {
            if( object.getId().equals( id)) {
                return object;
            }
        }
        return null;
    }
}

InheritLevel1Data.java

@NoArgsConstructor
@AllArgsConstructor
@Getter
@Setter
public class InheritLevel1Data<T> extends BaseObjectData implements ComparatorBase<T> {
    private String objectValue3;

    public InheritLevel1Data( String id, String d1, String d2, String d3) {
        super( id, d1, d2);
        this.objectValue3 = d3;
    }
    @Override
    public List<Difference> isSame(T otherObject) {
        List<Difference> differences = super.isSame( otherObject);
        if( ! getObjectValue3().equals( otherObject.getObjectValue3())) {
            differences.add( new Difference( getId(), getObjectValue3(), otherObject.getObjectValue3()));
        }
        return differences;
    }
}

RunnerTest.java

public class RunnerTest {
    private static final Logger logger = Logger.getLogger( "My logger");
    public static void main(String[] args) {
        List<BaseObjectData> objectDataList1 = buildList( "id-1", "data-1", "data-2", "data-3b");
        List<BaseObjectData> objectDataList2 = buildList( "id-1", "data-1", "data-2a", "data-3");
        List<Difference> differences = new ArrayList<>();
        for( BaseObjectData o: objectDataList1) {
            BaseObjectData o2 = (BaseObjectData) o.findMatchingObject( objectDataList2);
            differences.addAll( o.isSame( o2));
        }
        differences.forEach( v -> logger.info( "Verschil: " + v));
    }

    private static List<BaseObjectData> buildList( String id, String data1, String data2, String data3) {
        return List.of(
                new BaseObjectData( "BO_" + id, data1, data2),
                new InheritLevel1Data( "ID1_" + id, data1, data2, data3));
    }
}