如何从擦除转换泛型类型

Question

我有一个父类，Parent，有两个子类，A和B。我有一个接口，Function<Type1 extends Parent,Type2 extends Parent>，它允许程序员编写一个特定的函数，Type2 of(Type1 t)，将 Type1 带到 Type2。接口包装在一个类中，Wrapper<Type1 extends Parent,Type2 extends Parent>其中包含有用的信息，例如Class<Type1> type1Class等。

当我尝试为Wrapper类实现add方法时，出现了我的问题，Wrapper<Type1,Type2> add(Wrapper<Type1,Type2> additionalWrapper).我正在尝试将两个Function加在一起，但由于擦除，我很难输出Type2而不是Parent。

如何使add方法输出Type2而不是Parent？

public class Parent {
protected int value;
public void setValue(int x){ value = x; }
public int getValue(){ return value; }
public Parent(){}
public Parent(int x){setValue(x);}
public Parent add(Parent p){return null;}
}

public class A extends Parent{
public A(){ setValue(1); }
public A(int x){ setValue(x); }
public A(B b){ setValue( b.getValue()); }
public A add(A a){ return new A( getValue()+a.getValue()); }
public A add(B b){ return new A( getValue()*b.getValue()); }
}
public class B extends Parent{
public B(){ setValue(2); }
public B(int x){ setValue(x); }
public B(A a){ setValue(a.getValue()); }
public B add(B b){ return new B(getValue() + b.getValue()); }
public B add(A a){ return new B(getValue() * a.getValue()); }
}
public interface Function <Type1 extends Parent, Type2 extends Parent> {
public Type2 of(Type1 t);
}
public class Wrapper<Type1 extends Parent, Type2 extends Parent> {
protected Function<Type1,Type2> function;
protected Class<Type1> type1Class;
protected Class<Type2> type2Class;
public Wrapper(final Class<Type1> t1, final Class<Type2> t2, Function<Type1,Type2> x) {
type1Class = t1;
type2Class = t2;
function = x;
}
public Type2 of(Type1 t){
return function.of(t);
}
public Wrapper<Type1,Type2> add(final Wrapper<Type1,Type2> additionalWrapper){
return new Wrapper<Type1,Type2>( type1Class, type2Class, new Function<Type1,Type2>(){
public Type2 of(Type1 t){
try{
Type2 term = function.of(t);
Type2 summand = additionalWrapper.of(t);
Type2 sum = (Type2) term.add(summand); ///Problem happens here. term and summand are both interpreted as Parent by the erasure, I think, and therefore add outputs null, setting sum=null.
return sum;
} catch(Exception e){
e.printStackTrace();
return null;
}
}
});
}
}
public class Main {
public static void main(String[] args){
Wrapper<A, B> wrapper1 = new Wrapper<A, B>(A.class,B.class,new Function<A, B>() {
@Override
public B of(A a) {
return new B(a);
}
});
Wrapper<A, B> wrapper2 = new Wrapper<A, B>(A.class,B.class,new Function<A, B>() {
@Override
public B of(A a) {
B b = new B();
return b.add(a);
}
});
Wrapper<A,B> wrapper3 = wrapper1.add(wrapper2);
A a = new A(3);
B b = wrapper3.of(a);
System.out.println(b.getValue()); ///Error happens here because b was set to null and therefore doesn't contain int value.
}
}

Answer 1

正如路易斯·瓦瑟曼(Louis Wasserman(在评论中建议的那样，我需要在单个被覆盖的函数中使用实例Parent add(Parent p)。

在类 A 和 B 中，我需要有这个函数：

@Override
public Parent add(Parent p){
if (p instanceof A){
A a = (A) p;
return add(a);
}
else if (p instanceof B){
B b = (B) p;
return add(b);
}
else return null;
}

Answer 2

基本上你没有两种方法来添加 A 和 B，它违背了多态性或 SOLID 原则。你可以像下面这样构建你的课程 -

class A extends Parent{
public A(){ setValue(1); }
public A(int x){ setValue(x); }
public A(B b){ setValue( b.getValue()); }
@Override
public A add(Parent a){ return new A( getValue()+a.getValue()); }
}
class B extends Parent{
public B(){ setValue(2); }
public B(int x){ setValue(x); }
public B(A a){ setValue(a.getValue()); }
@Override
public B add(Parent b){ return new B(getValue() + b.getValue()); }
}

由于add是在 Parent 中定义的，因此只有一个实现就足够了。在当前场景中，由于类A中add的签名与Parent中的签名不匹配，因此该方法根本不被覆盖

您将知道是否在添加方法上添加@Override。编译器将抛出错误。

希望这有帮助。