返回泛型超类

Question

对于一堆带有泛型的包装类，我的继承结构遇到了一些麻烦。这基本上是结构：

public abstract class SuperWrapper<E extends Super>{
    private E wrappedObject;
    public E getWrappedObject(){
        return wrappedObject;
    }
}

public abstract class MiddleWrapper<E extends Middle> extends SuperWrapper<E>{}

public class SubAWrapper extends MiddleWrapper<SubA>{}

public class SubBWrapper extends MiddleWrapper<SubB>{}

public class Super{}

public class Middle extends Super{}

public class SubA extends Middle{}

public class SubB extends Middle{}

public static MiddleWrapper<?> findMiddle(String id){
    SubAWrapper a = new SubAWrapper();
    SubBWrapper b = new SubBWrapper();
    if(returnSubA){
        return a;
    } else{
        return b;
    }
}

public static <E extends Middle> MiddleWrapper<E> findMiddle(String id){
    SubAWrapper a = new SubAWrapper();
    SubBWrapper b = new SubBWrapper ();
    if(returnSubA){
        return (MiddleWrapper<E>) a;
    } else{
        return (MiddleWrapper<E>) b;
    }
}

这将与当前代码一起编译和工作，但是，这似乎很危险。如果调用方像这样使用这个方法:middlewrapper middle=findMiddle（“1”）； ，它将很好地编译，但是如果findMiddle尝试返回SubBWrapper，则在运行时会有一个ClassCastException。我以为行得通却行不通的是：

public static MiddleWrapper<Middle> findMiddle(String id){
    SubAWrapper a = new SubAWrapper ();
    SubBWrapper b = new SubBWrapper ();
    if(returnSubA){
        return (MiddleWrapper<Middle>) a; //Compile error here
    } else{
        return (MiddleWrapper<Middle>) b; //and here
    }
}

所以我的问题基本上是，有没有正确的方法来编写编译、运行并遵循最佳实践的方法findMiddle？

对于额外的学分，有没有一种方法可以编写一个方法，使它返回一个列表，同时包含SubA和subb。如下所示,但不使用通配符：

public static List<MiddleWrapper<?>> getAllMiddle(){
    List<MiddleWrapper<?>> ret = Lists.newArrayList();
    ret.add(new SubAWrapper());
    ret.add(new SubBWrapper());
    return ret;
}

Answer 1

MiddleWrapper是用Middle类参数化的泛型类：

public abstract class MiddleWrapper<E extends Middle> extends SuperWrapper<E>{}

如果要提供一个方法，该方法返回middlewrapper的列表，该middlewrapper至少具有两个不同的泛型类型，则您没有很多选择。

如果您不需要对middle子类设置任何可能返回的约束。
您显示的方法很好：

public static List<MiddleWrapper<?>> getAllMiddle() {
  List<MiddleWrapper<?>> ret = Lists.newArrayList();
  ret.add(new SubAWrapper());
  ret.add(new SubBWrapper());
  return ret;
}

你说：

这会编译并起作用，但SonarQube警告在返回类型中使用通配符，从我的谷歌搜索来看，这不是应该忽略的警告之一。

为什么在middlewrapper<？>中使用？会是一个不好的做法？
类middlewrapper是泛型的，在您的方法中，您可以返回用作泛型的任何类型的middle。
这是此用例的方法。

public class ValidMiddle extends Middle {...}

public class SubA extends ValidMiddle{...}

public class SubB extends ValidMiddle{...}

而方法应该是：

public static List<MiddleWrapper<? extends ValidMiddle>> getAllMiddleWithMoreSpecificType() {
  List<MiddleWrapper<? extends ValidMiddle>> ret = Lists.newArrayList();
  ret.add(new SubAWrapper());
  ret.add(new SubBWrapper());
  return ret;
}

请注意，对于应该操作此声明类型的客户端来说，这种方式稍微冗长一些：

 List<MiddleWrapper<? extends ValidMiddle>> listOfWrappers = getAllMiddle();