来自超类的 Java 隐式通用参数

Question

编辑：我让这个例子变得更简单了

我想创建一个具有泛型参数的类，该类扩展具有泛型参数 X 的类型，并且我想引用该类型 X 而不明确声明它。

我不确定这是否也回答了这个问题Why can't I use a type argument in a type parameter with multiple bounds?

class Fruit<T> {}

// I don't want to have to redefine T e.g. <F extends Fruit<T>,T>
// because T should be implicit for Fruit (see Example of instance below)
// the below will not compile, but is roughly what I'd like
class Box<F extends Fruit<T>> {
    T get( F fruit ) { return null; }
}

实例示例

class Apple extends Fruit<String>

// this is what I would like, but this won't compile with above definiton
class AppleBox extends Box<Apple> {
    // String get( Apple apple ) should be implicit
}

我不想声明

class AppleBox extends Box<Apple,String>

因为字符串是这里唯一可用的选项，应该隐式知道

Answer 1

Fruit 类内的泛型类型的范围在 Fruit 类本身内。该泛型类型变量无法在类之外访问。

因此，您必须定义 T 来代替泛型类型，并且由于您在其他地方使用变量 T，因此您也不能将其省略。

所以重申一下 Fruit 中的类型 T 仅在类型 fruit 中可见，因此要在 Box 中使用它，您需要在某处再次定义该类型：

public class Outer {

  class Fruit<T> {
    T body;
  }

  abstract class Box<F extends Fruit<T>, T> {
    abstract T get( F fruit );
  }
}

如果您希望 T 对 Fruit 隐含，则不要在 Fruit 类中定义泛型参数 T，而是在外部类中定义。

public class Outer<T> {

  class Fruit {
    T body;
  }

  abstract class Box<F extends Fruit> {
    abstract T get( F fruit );
  }
}

这个范围问题的一个类比是下面的代码：

for (int i = 0; i < 10; i++) {
  // stuff
}
for (int i = 0; i < 20; i++) { // i from previous loop is not visible here
  // stuff
}
System.out.println(i); // variable not defined: i

Answer 2

解决方案编辑：

interface Fruit<T> {
    T get();
}

class Box<F extends Fruit<?>> {

    <R> R get(F fruit) { 
        @SuppressWarnings("unchecked")
        R ret = (R) fruit.get();

        return ret;
    }
}

class Apple implements Fruit<String> {
    @Override
    public String get() {
        return "Apple";
    }
}

class Something implements Fruit<String> {
    @Override
    public String get() {
        return "Something";
    }
}

//this is what I would like, but this won't compile with above definiton
class AppleBox extends Box<Apple> {
    // ...
}

class Main {
    public static void main(String[] argv) {

        Apple apple = new Apple();
        Something something = new Something();

        AppleBox ab = new AppleBox();

        System.out.println( ab.get(apple) );
        // this will fail
        System.out.println( ab.get(something) );)
    }
}

如果你想要更多关于 Box.get() 返回类型的类型安全性，只需使用静态方法，因为上面的 Box.get() 返回 Object，而不是 T。

interface Fruit<T> {
    T get();
}

class Box<F extends Fruit<?>> {

    <R> R get(F fruit) { 
        @SuppressWarnings("unchecked")
        R ret = (R) fruit.get();
        return ret;
    }

    public static <P, Q extends Fruit<P>> P get(Box<Q> box, Q fruit) {
        return box.get(fruit);
    }
}

class Apple implements Fruit<String> {
    @Override
    public String get() {
        return "Apple";
    }
}

class Something implements Fruit<String> {
    @Override
    public String get() {
        return "Something";
    }
}

//this is what I would like, but this won't compile with above definiton
class AppleBox extends Box<Apple> {
    // ...
}

class Main {
    public static void main(String[] argv) {

        Apple apple = new Apple();
        Something something = new Something();

        AppleBox ab = new AppleBox();

        System.out.println( AppleBox.get(ab, apple) );      
        System.out.println( AppleBox.get(ab, something) );  // this will fail

        Apple p = AppleBox.get(ab, apple); // fail: return type mismatch
    }
}