Java 泛型类的继承

按照约定，类型参数名称命名为单个大写字母，以便可以在使用普通类或接口名称时能够容易地区分类型参数。以下是常用的类型参数名称列表 -

E - 元素，主要由Java集合(Collections)框架使用。
K - 键，主要用于表示映射中的键的参数类型。
V - 值，主要用于表示映射中的值的参数类型。
N - 数字，主要用于表示数字。
T - 类型，主要用于表示第一类通用型参数。
S - 类型，主要用于表示第二类通用类型参数。
U - 类型，主要用于表示第三类通用类型参数。
V - 类型，主要用于表示第四个通用类型参数。
以下示例将展示上述概念的使用。
 

1、继承关系：

class Father<T> {  
    T data;  
  
    public Father(T data) {  
        this.data = data;  
    }  
  
    @Override  
    public String toString() {  
        return "Father [data=" + data + "]";  
    }  
  
}  
  
class Son1<T> extends Father<T> {// 最正常的继承，子类的泛型参数和父类的参数是一致的  
  
    public Son1(T data) {  
        super(data);  
    }  
  
    @Override  
    public String toString() {  
        return "Son1 [data=" + data + "]";  
    }  
  
}  
  
class Son2<E, F> extends Father<F> {// 子类增加了一个泛型参数，父类的泛型参数不能遗漏，所以仍然要定义  
  
    E otherData;  
  
    public Son2(F data, E otherData) {  
        super(data);  
        this.otherData = otherData;  
    }  
  
    @Override  
    public String toString() {  
        return "Son2 [otherData=" + otherData + ", data=" + data + "]";  
    }  
  
}  
  
class Son3 extends Father {// 继承时不指定父类的泛型参数,会有警告信息：Father is a raw type.  
                            // References to generic type Father<T> should be  
                            // parameterized  
  
    public Son3(Object data) {// 这个的data类型为Object  
        super(data);  
    }  
  
    @Override  
    public String toString() {  
        return "Son3 [data=" + data + "]";  
    }  
  
}  
  
// 继承时指定父类的泛型参数，子类就不用再写泛型参数，如果写了，那就是子类自己新增加的  
class Son4 extends Father<Integer> {  
  
    public Son4(Integer data) {  
        super(data);  
    }  
  
    @Override  
    public String toString() {  
        return "Son4 [data=" + data + "]";  
    }  
  
}  
  
// 父类指定了类型，子类又增加了，这时子类的只是新增加的泛型参数，跟父类没有关系  
class Son5<T> extends Father<Integer> {  
    T otherData;  
  
    public Son5(Integer data, T otherData) {  
        super(data);  
        this.otherData = otherData;  
    }  
  
    @Override  
    public String toString() {  
        return "Son5 [otherData=" + otherData + ", data=" + data + "]";  
    }  
  
}  
  
// 子类的泛型参数是Integer 这个是我无意使用的，当然真实项目是绝对不允许这样使用的，一般泛型参数命名都是单个大写字母  
// 这里使用只是来说明万一泛型参数和一个类名相同了，别糊涂了（相同了都是来故意迷糊人的）  
// 这里的Integer 不是java.lang.Integer 它只是一个泛型参数名称 ，恰好相同，跟Son1是没有区别的  
// 它出现这里会把类中所有的Integer(java.lang.Integer) 都替换成 泛型参数  
// 警告提示：The type parameter Integer is hiding the type Integer  
// 所以传给父类的Integer，也不是java.lang.Integer，也只是一个类型参数  
class Son6<Integer> extends Father<Integer> {  
  
    Integer otherData;// 它是什么类型呢？java.lang.Integer？NONONO 只能说不确定！  
  
    public Son6(Integer data, Integer otherData) {  
        super(data);  
        this.otherData = otherData;  
    }  
  
    @Override  
    public String toString() {  
        return "Son6 [otherData=" + otherData + ", data=" + data + "]";  
    }  
  
}  
// 下面是错误的情况 父类的类型参数不明确，这会让编译器迷糊 ，让它迷糊了，就是错了！  
// class Son7 extends Father<T>{}  
  
// 父类和子类的泛型参数具有关系  
class Son8<T, E extends T> extends Father<T> {  
  
    E otherData;  
  
    public Son8(T data, E otherData) {  
        super(data);  
        this.otherData = otherData;  
    }  
  
    @Override  
    public String toString() {  
        return "Son8 [otherData=" + otherData + ", data=" + data + "]";  
    }  
  
}  
  
// 下面的写法也是错误的，要是父类的T为Object 这时E为什么呢？  
// class Son9<E, E super T> extends Father<T> {  
//  
// public Son9(T data) {  
// super(data);  
// }  
// }  

 

2、测试类：

public class GenericityTest {  
    public static void main(String[] args) {  
        // 这里只测试Son6和Son8 其他很简单，自己测试吧！  
        System.out.println(new Son6<String>("son6", "son6"));// 构造函数两个参数类型一样的  
        System.out.println(new Son8<Number, Long>(8, 8L));// 构造函数 两个参数具有父子关系  
    }  
} 

3、掩盖类型：

//掩盖情况下，用全类名指定父类的类型，这样父类的类型就唯一确定了，不跟子类一样了  
class Son6<Integer> extends Father<java.lang.Integer> {  
  
    Integer otherData;// 它是什么类型呢？java.lang.Integer？NONONO 只能说不确定！  
  
    public Son6(java.lang.Integer data, Integer otherData) {  
        super(data);  
        this.otherData = otherData;  
    }  
  
    @Override  
    public String toString() {  
        return "Son6 [otherData=" + otherData + ", data=" + data + "]";  
    }  
  
} 

4、<T> T和T

这个<T> T 表示的是返回值T是泛型，T是一个占位符，用来告诉编译器

public class Demo {

    public static void main(String[] args) {

        Demo demo = new Demo();

        //获取string类型
        List<String> array = new ArrayList<String>();
        array.add("test");
        array.add("doub");
        String str = demo.getListFisrt(array);
        System.out.println(str);

        //获取nums类型
        List<Integer> nums = new ArrayList<Integer>();
        nums.add(12);
        nums.add(13);

        Integer num = demo.getListFisrt(nums);
        System.out.println(num);
    }

    /**
     * 这个<T> T 可以传入任何类型的List
     * 参数T
     *     第一个 表示是泛型
     *     第二个 表示返回的是T类型的数据
     *     第三个 限制参数类型为T
     * @param data
     * @return
     */
    private <T> T getListFisrt(List<T> data) {
        if (data == null || data.size() == 0) {
            return null;
        }
        return data.get(0);
    }
}

返回值，直接写T表示限制参数的类型，这种方法一般多用于共同操作一个类对象

public class Demo2<T> {
    public static void main(String[] args) {

        //限制T 为String 类型
        Demo2<String> demo = new Demo2<String>();

        //获取string类型
        List<String> array = new ArrayList<String>();
        array.add("test");
        array.add("doub");
        String str = demo.getListFisrt(array);
        System.out.println(str);

        //获取Integer类型 T 为Integer类型
        Demo2<Integer> demo2 = new Demo2<Integer>();
        List<Integer> nums = new ArrayList<Integer>();
        nums.add(12);
        nums.add(13);
        Integer num = demo2.getListFisrt(nums);
        System.out.println(num);
    }

    /**
     * 这个只能传递T类型的数据
     * 返回值 就是Demo<T> 实例化传递的对象类型
     * @param data
     * @return
     */
    private T getListFisrt(List<T> data) {
        if (data == null || data.size() == 0) {
            return null;
        }
        return data.get(0);
    }
}