泛型之泛型类

泛型类
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
}
}