Question

我有三个班级：

class ClassR {}
class ClassA<T extends ClassR>{}    
class ClassB<E extends ClassA<T extends ClassR>> extends ClassA<T> {
    void foo(T param) {
    }

    void bar(E param) {
    }
}

除非我将其更改为

，否则第三个类不会编译

class ClassB<E extends ClassA<T>, T extends ClassR> extends ClassA<T> {
    void foo(T bar) {
    }

    void bar(E param) {
    }
}

有没有办法只保留创建ClassB时需要传递的E参数，并推断T？例如，使用起来会很方便：

new ClassB<ClassA<ClassR>>()

而不是：

new ClassB<ClassA<ClassR>, ClassR>()

Answer 1

这种更简单的方法可能适合您：

class ClassR {}
class ClassA<T extends ClassR>{}    

class ClassB<T extends ClassR> extends ClassA<T> {
    void foo(T bar) {
    }

    void bar(ClassA<T> param) {
    }
}

然后使用会绕过对ClassA的任何引用变为：

class SubR extends ClassR {}

ClassB<SubR> obj = new ClassB<SubR>();

Answer 2

不确定这是否是您想要的答案，但最简单的版本肯定是：

class ClassR {
}

class ClassA<T extends ClassR> {
}

class ClassB<T extends ClassR> extends ClassA<T> {

    void foo(T bar) {
    }
}

public void test() {
    ClassB<ClassR> classB = new ClassB<>();
}

Answer 3

当E类型扩展ClassA时，您可以在其声明中安全地省略ClassA类型参数。
在第二个参数中强制执行ClassA类型参数到ClassB。
见下面的代码：

class ClassB<E extends ClassA, T extends ClassR> extends ClassA<T> {

  private ClassA ob;

  public ClassB(E e, T t)  {
    super(t);
    ob = e;
  }

}

使用示例：

class ClassR { 
   public ClassR() {};
}

class ClassS extends ClassR {
  private int x;
  public ClassS(int x) {
     super();
     this.x = x;
  }
}

public static void test() {
  ClassS data1 = new ClassS(1);
  ClassB <ClassB, ClassS> first = new ClassB<>(null, data1);
  ClassS data2 = new ClassS(2);
  ClassB <ClassB, ClassS> second = new ClassB<>(first, data2);
}

嵌套在泛型中扩展

3 个答案: