泛型之泛型类

泛型类

public class A<T> {
    //在成员变量上使用泛型
    private T t;
    
    public A() {}
    
    //构造参数类型上使用泛型
    public A(T t) {
       this.t = t;
    }
    
    //方法返回值上使用泛型
    public T getT() {
        return t;
    }
    
    //方法的参数上使用泛型
    //这是泛型类的方法，而不是泛型方法
    public void setT(T t) {
        this.t = t;
    }
    
    //方法的返回值和参数类型上使用泛型
    public T foo(T t) {
        return t;
    }
    
    public void foo2() {
        //T t = ....; //局部变量的引用类型上使用泛型
        //new T(); //不可以这样使用
    }
    
    public void foo3() {
        //在创建泛型类对象时，即为类型变量赋值，这里将T赋值为String类型
        A<String> a = new A<String>();
        //将T赋值为Integer类型
        A<Integer> a1 = new A<Integer>();
    }
}

A是一个泛型类，T它是一个变量，需要赋类型值，如果有多个类型变量，就用逗号分隔，比如 Jdk 的 Map 接口：interface Map<K,V> {}。
定义：具有一个或多个类型变量的类，称之为泛型类。
泛型类是一个存在类型变量的类，存在可变的因素，所以说是一个不完整的类。那么当子类去继承的时候，把里面的类型变量赋予了类型，那么这个类就完整了，就可以使用了。

泛型类的继承

public class B<T> {}

class BB extends B<String> {}

创建BB对象的两种方式

• B<String> b = new BB()
• BB b = new BB()

错误方式

• BB<String> bb = new BB<String>()

错误原因：BB 继承了泛型类 B，但 BB 并不是泛型类，所以不能这样创建对象。

public class C<T> {}

class CC<E> extends C<E> {}
class CCC<E> extends C<Integer> {}

创建CC对象

• C<String> c = new CC<String>()
• C<Integer> c = new CC<Integer>()

泛型引用和创建，两端给出的泛型变量必须相同（等号前后的泛型类型应该保持一致），否则会报错。
CC是泛型类，它的父类也泛型类，它可以给父类传递类型常量，也可以传递变量，这里传递的是变量。
CCC同样是泛型类，它的父类也是泛型类，它传递的是常量。

泛型类的子类重写父类方法

public class D<T> {
    private T bean;
    
    public void setBean(T bean) {
        this.bean = bean;
    }
}

class DD<E> extends D<E> {
    /**
     * 子类重写父类方法，参数类型必须是E，因为子类在定义
     * 已经把类型E赋给了父类。
     */
    @Override
    public void setBean(E o) {
        //TODO
    }
}
class DDD<E> extends D<String> {
    //子类定义时已经把类型String赋给了父类，所以方法重写时类型是String
    public void setBean(String str) {
        //TODO
    }
}