Question

假设我有以下设置

public class Parent{

}

public class Child1 extends Parent{

}

public class Child2 extends Parent{

}

我可以做以下

Class<Parent> test = Parent.class

但以下给我一个错误。

Class<Parent> test = Child1.class

我该如何解决这个问题？

Answer 1

试试这个

    Class<? extends Parent> test1 = Child1.class;

Answer 2

其他人已经说过了

Class<? extends Parent> test1 = Child1.class;

是解决方案。

所以现在问题可能出现为什么

Class<Parent> test1 = Child1.class;

首先没有工作？或者，让我用不同的方式对其进行说明，为什么Generic<T>仅适用于T而不是其子类？

那么，这与你能做些什么有关。想象一下像

这样的课程

public class Generic<T> {
    private T content
    public void accept(T stuff) { content = stuff; }
    public void accept(Supplier<T> stuff) { content = stuff.get(); }
    public T get() { return content; }
    public void put(Consumer<T> c) { c.put(content); }
}

现在我们使用它并期望Generic<Number>在两个方向上正常工作：

Supplier<Integer> si = () -> 42;
Supplier<Number> sn = () -> 42;
Consumer<Integer> ci = n -> System.out.println(c);
Consumer<Number> cn = n -> System.out.println(c);

Generic<Integer> gi = new Generic<Integer>();
Generic<Number> gn = new Generic<Number>();

gi.accept(si); // works
gi.accept(sn); // won't work (1), that's ok
gi.put(ci); // works
gi.put(cn); // won't work (2), but should

gn.accept(si); // won't work (3), but should
gn.accept(sn); // works
gn.put(ci); // won't work (4), that's ok
gn.put(cn); // works

如果类型系统允许组合所有内容，则（1）（2）（3）（4）的所有内容都可以工作，而且过于宽容。因此，您必须明确说明您希望它工作的方向，才能容忍：

public class Generic<T> {
    private T content
    public void accept(T stuff) { content = stuff; }
    public void accept(Supplier<? extends T> stuff) { content = stuff.get(); }
    public T get() { return content; }
    public void put(Consumer<? super T> c) { c.put(content); }
}

现在，accept()接受提供T或子类的所有内容，put()接受接受T或超类的所有内容。

这样，

gi.put(cn); // (2)
gn.accept(si); // (3)

同时工作（gi.put()接受Consumer<Number>和gn.accept()接受Supplier<Integer>），而

gi.accept(sn); // still won't work (1), that's ok
gn.put(ci); // still won't work (4), that's ok

不起作用，因为分配存在兼容性问题。

如何在子类中使用`Class <t>`，其中T是父类</t>

2 个答案: