时间戳

首页 > 解决方案 > 有没有更好的方法可以在继承类中处理我的 Generic BaseClass？

java - 有没有更好的方法可以在继承类中处理我的 Generic BaseClass？

问题描述

我对泛型的使用和理解有疑问。我以前使用过泛型，但现在我到了无法再进一步的地步

这是我的基本类，应该由其他类扩展：

public class BaseFiller<T> {

private WorkBook workBook;
private List<T> act_Bwa;
private List<T> act_Balance;
private List<T> p_l_v_e_L;


public BaseFiller(WorkBook workBook,
                  List<T> act_Bwa,
                  List<T> act_Balance,
                  List<T> p_l_v_e_L) {
    this.workBook = workBook;
    this.act_Bwa = act_Bwa;
    this.act_Balance = act_Balance;
    this.p_l_v_e_L = p_l_v_e_L;
}


protected static <T> Predicate<T> distinctByProperty(Function<? super T, ?> keyExtractor) {
    Map<Object, Boolean> seen = new ConcurrentHashMap<>();
    return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
}



protected static <T> Map<Integer, String> mapListToMap(Collection<? extends T> entityList, Function<? super T, Integer> intProperty,
                                                           Function<? super T, String> stringProperty) {
    return entityList.stream()
            .collect(Collectors.toMap(intProperty, stringProperty));
}


 //Getter & Setter

 }

以下类扩展了基类：

public class FinanceBalanceFiller<T> extends BaseFiller<T> {

.
.
.


public FinanceBalanceFiller(WorkBook workBook, List<T> act_Bwa,
                            List<T> act_Balance,
                            List<T> p_l_v_e_L) {
    super(workBook, act_Bwa, act_Balance, p_l_v_e_L);
}



public Map<Integer, String> makeMapFromAllLists() {
    List<ResultlinevaluesEntity> res = new ArrayList<>();
    for (List<ResultlinevaluesEntity> list : getAct_Bwa()) {
        res.addAll(list);
    }

    //removes all duplicates from List by DbNr
    List<ResultlinevaluesEntity> resWithoutDuplicates = res.stream()
            .filter(distinctByProperty(ResultlinevaluesEntity::getDb_nr))
            .collect(Collectors.toList());

    //creates HashMap (Key = DbNr, Value = name)
    return mapListToHashMap(resWithoutDuplicates, ResultlinevaluesEntity::getDb_nr,
            ResultlinevaluesEntity::getName);
}

在 makeMapFromAllLists() 方法中，我的 For 循环有问题。它吐出一个类型相互不兼容的错误。

错误：(116, 68) java：不兼容的类型：T 无法转换为 java.util.List

我明白这一点，我改变了它：

    List<T> res = new ArrayList<>();
    for (List<T> list : getAct_Bwa()) {
        res.addAll(list);
    }

但这也不起作用，因为这些类型也不适合这里。此外，我从基类中遇到了 Methoddode distinctByProperty 的问题。编译器在这里说：

不能从静态上下文中引用非静态方法

与此同时，我完全感到困惑，我无法再进一步了。

所以，我的目标是方法 makeMapFromAllLists() 中的所有方法不仅服务于 ListType“ResultLineValuesEntity”，还服务于其他类型。

有人可以帮助我并向我展示此时如何处理泛型吗？

标签： javagenericsinheritance

解决方案

它是addAllinstead of的用法add，但存在简化：

List<ResultlinevaluesEntity> res = new ArrayList<>();
for (List<ResultlinevaluesEntity> actBwa : getAct_Bwa()) {
    res.add(actBwa);
}

List<ResultlinevaluesEntity> res = new ArrayList<>();
res.addAll(getAct_Bwa());

List<ResultlinevaluesEntity> res = new ArrayList<>(getAct_Bwa());

编辑后的问题：（不想要类型参数 T）

并行类层次结构存在（有时是不可避免的）（反）模式

如果你有一个项目/实体基类 ItemBase。

class ItemBase
class ItemA extends ItemBase
class ItemB extends ItemBase

和一个容器基类ContainerBase

class ContainerBase<T extends ItemBase>
    List<T> items
    List<T> getItems();

class ContainerA extends ContainerBase<ItemA>
class ContainerB extends ContainerBase<ItemB>

这是让类型安全的类区分List<ItemA>和的好方法List<ItemB>。否则，您可能只有List<ItemBase>.

最好是不需要ContainerAand ContainerB。

你也可以这样做（如果你不想要一个参数）：

class ContainerBase
    List<ItemBase> items;
    public List<ItemBase> getItems();

class ContainerA extends ContainerBase
    @Override
    public List<ItemA> getItems() {
        return items.stream().map(ItemA.class::cast).collect(Collectors.toList());
    }

class ContainerB extends ContainerBase
    @Override
    public List<ItemB> getItems() {
        return items.stream().map(ItemB.class::cast).collect(Collectors.toList());
    }

推荐阅读