Question

我有以下代码：

public class Inheritance {

    class A<T,U,V>{

    }

    class B<T,U,V> extends A<T,U,T>{        

    }
}

有人可以解释一下，它实际上是如何工作的吗？ B类仅扩展参数为“ T，U，T”的A类，还是扩展实际的A“ T，U，V”类？

Answer 1

A的{{1}} = T的{{1}}
B的{{1}} = T的{{1}}
A的{{1}} = U的{{1}}

Answer 2

B类是否仅扩展了A类，其参数为“ T，U，T”

是的。

还是扩展了实际的A“ T，U，V”类？

这是一个模板，没有实际的通用参数。这是将自己的参数类型与父级的参数类型进行匹配的一种方法。如果有一个B<String, Integer, Long>实例，将有一个父对象A<String, Integer, String>支持它。

Answer 3

让它变成一个真实的例子：

 public class Inheritance {
        public static class A<T,U,V>{
             T t;
             U u;
             V v;

             A(T t, U u, V v) {
                this.t = t;
                this.u = u;
                this.v = v;
            }

            T getT() {return t;}
            U getU() {return u;}
            V getV() {return v;}
        }

        public static class B<T,U,V> extends A<T,U,T>{
            public B(T t, U u, V v) {
                super(t, u ,t);
            }
        }

        public static void main(String[] args) {
            B<Boolean, Integer, String> b = new B<>(false, 1, "string");
           // 't' attribute is Boolean 
           // since type parameter T of class B is Boolean
           Boolean t = b.getT(); 
           // 'v' attribute is Boolean 
           // since type parameters T and V of class A must have the same type as 
           // type parameter T of class B 
           Boolean v = b.getV(); 
        }
    }

基本上，类B扩展了类A（具有三个泛型参数）。通过声明B<T,U,V> extends A<T,U,T>，您只需将A的第一个和A的第三个通用参数绑定到B的第一个参数的相同类型

如类B的构造函数中的示例所示，我们具有三种不同的类型-布尔，整数，字符串，但是在类A的构造函数中，我们只有两种不同的类型布尔，整数，因为类A的第1和第3构造函数参数都是绑定到布尔类型

有关泛型和继承的更多信息，请参见： https://docs.oracle.com/javase/tutorial/java/generics/inheritance.html

Answer 4

在此代码中，每个类的模板化类型“ 标识符”没有相互链接，让我修改代码段以解释我的意思：

public class Inheritance {
    class A<T,U,V> { }

    class B<I,J,K> extends A<I,J,I>{ }
}

代码与以前相同。您可以看到I，J，K和T，U，V之间没有“命名”关联。

这里将类型I和J转发给A。从A的角度来看，将替换为：T = I，U = J，V = I。

带参数的Java泛型-继承

4 个答案: