带参数继承的Java泛型

我有以下代码：

public class Inheritance {

    class A<T,U,V>{

    }

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

    }
}

公共类继承{
甲级{
}
类B扩展了{
}
}

---

谁能给我解释一下，它到底是怎么工作的？类B是只扩展一个类，参数是“T，U，T”，还是扩展了实际的一个“T，U，V”类？

A

T

=

B

T

A

的

U

=

B

的

U

A

的

V

=

B

的

T

B<String, Integer, Void> b = null;
A<String, Integer, String> a = b;

B=null；
A=b；

B类是否只扩展了一个类，参数是“T，U，T”

是的，没错

或者它扩展了实际的“T，U，V”类

---

这是一个模板，没有实际的通用参数。这是一种将您自己的参数类型与父参数类型相匹配的方法。如果有一个

B

实例，则会有一个父对象

a

支持它。

让我们把它放在实际示例中：

 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(); 
        }
    }

公共类继承{
公共静态A类{
T；
U U；
V V；
A（T，U，V）{
t=t；
这个。u=u；
这个，v=v；
}
T getT（）{return T；}
U getU（）{return U；}
V getV（）{return V；}
}
公共静态类B扩展了{
公共B（T、U、V）{
超级（t，u，t）；
}
}
公共静态void main（字符串[]args）{
B=新的B（假，1，“字符串”）；
//“t”属性是布尔值
//因为类B的类型参数T是布尔型的
布尔t=b.getT（）；
//“v”属性是布尔值
//因为A类的类型参数T和V必须与
//B类的类型参数T
布尔值v=b.getV（）；
}
}

基本上，类B扩展了类A（它有三个泛型参数）。通过声明

B扩展A

，您只需将A的第一个和第三个泛型参数绑定到相同类型的B的第一个参数

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

有关泛型和继承的更多信息，请参见：

---

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

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

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

公共类继承{
A类{}
类B扩展了{}
}

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

---

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

请您解释一下您打算用示例显示什么？是的，我更新了我的答案并注释掉了这个例子