转载

Java系列之泛型

自从 JDK 1.5 提供了泛型概念，泛型使得开发者可以定义较为安全的类型，不至于强制类型转化时出现类型转化异常，在没有反省之前，可以通过 Object 来完成不同类型数据之间的操作，但是强制类型转换（向下转型）在不确定具体类型的情况下会出错，泛型机制的引入就是解决 数据类型不明确 的问题。

定义泛型类

定义一个泛型类，语法如下:

//定义泛型类
class 类名<T>{
    
}

其中，T 表示一个类型的名称，T 可以表示成其他名称，一般习惯写成 T，<> 里面的类型可以有多个，中间以逗号隔开，下面是一个泛型类，具体如下：

/**
 * 定义泛型类
 * @author jzman
 * @param <T>
 */
public class GenercityClass<T1,T2> {
    
    private T1 score;
    private T2 desc;
    
    public GenercityClass() {}
    
    public GenercityClass(T1 score, T2 desc) {
        this.score = score;
        this.desc = desc;
    }
    public T1 getScore() {
        return score;
    }
    public void setScore(T1 score) {
        this.score = score;
    }
    public T2 getDesc() {
        return desc;
    }
    public void setDesc(T2 desc) {
        this.desc = desc;
    }
    
    public static void main(String[] args) {
        //使用时指定具体类型，具体类型只能是引用类型，不能时基本类型，如 int
        GenercityClass<Integer, String> genercity = new GenercityClass<>(90,"A");
        int score = genercity.getScore();
        String desc = genercity.getDesc();
        System.out.println("score="+score+",desc="+desc);
    }
}

显然，使用泛型定义的类可以在使用时根据不同的需求指定 <T1,T2> 所代表的真实类型，这样就不会有类型转换操作，将不会出现 ClassCastException 异常，编译器会提前检查类型是否匹配，下面这样会出错，具体如下：

GenercityClass<Integer, String> genercityClass = new GenercityClass<>();
//符合指定的具体类型
genercityClass.setScore(80);
//不能将String的值赋值给Integer类型的变量
genercityClass.setScore("A");

定义泛型接口

定义泛型接口，语法具体如下：

//定义泛型接口
interface 接口名<T>{
    方法返回值类型 方法名<T t>;
}

下面是一个泛型接口的定义，具体如下：

/**
 * 泛型接口：只能在方法中使用指定泛型
 * @author jzman
 */
public interface GenercityInterface<T> {
    //泛型不能在静态属性前面使用
//    T a;
    //方法中使用泛型
    void start(T t);
}

在接口中使用泛型，只能在接口的方法中使用泛型，不能在接口的属性上使用泛型，因为 Java 接口中的属性是用 public static final 修饰的 ，而泛型所代表的具体类型是在使用时确定的，编译时还不知道泛型所表示的具体类型。

定义泛型方法

定义泛型方法，语法具体如下：

//定义泛型方法
修饰符 <T> 返回值类型 方法名{
    
}

创建一个类，具体如下：

package com.manu.genericity;

public class PersonBean {
    private String name;
    private int age;
    //省略 Getter、Setter等方法
    //...
}

下面是一个泛型方法的定义，具体如下：

/**
 * 泛型方法
 * @author jzman
 */
public class GenercityMethod {
    public static void main(String[] args) {
        PersonBean bean = new PersonBean("tom",10);
        printA("string");
        printA(bean);
        printB(bean);
    }
    //泛型不指定其超类，由于类型无法确定，只能访问其信息
    public static <T> void printA(T t) {
        System.out.println(t);
    }
    //泛型指定超类，可以修改其泛型表示的实体信息
    public static <T extends PersonBean> void printB(T t) {
        t.setName("haha");
        System.out.println(t);
    }
}

输出结果如下：

string
PersonBean [name=tom, age=10]
PersonBean [name=haha, age=10]

由于泛型方法 printA 具体类型不确定，不能修改其泛型信息，printB 指定了其超类，一定程度上可以修改泛型表示的具体类型的信息。泛型可以定义在方法中，是否有泛型方法，与其所在的类是否有泛型没有关系。

泛型继承

子类继承父类的时候，泛型又该如何处理呢，下面的子类继承带泛型父类的几种情况，具体如下：

/**
 * 泛型父类
 * @author jzman
 */
public abstract class GenercityEClass<T> {
    T name;
    public abstract void print(T t);
}

/**
 * 子类为泛型类，类型在使用时确定
 * @author jzman
 * @param <T>
 */
class Child1<T> extends GenercityEClass<T>{
    T t; //子类的属性由子类决定
    @Override
    public void print(T t) {
        //父类的属性随父类决定
        T name = this.name;
    }
}

/**
 * 子类指定具体类型
 * @author jzman
 */
class Child2 extends GenercityEClass<String>{
    Integer t; //子类的属性由子类决定
    @Override
    public void print(String t) {
        //父类的属性随父类决定
        String name = this.name;
    }
}

/**
 * 父类泛型的擦除
 * 子类是泛型类，父类不指定类型，泛型擦除是使用Object来代替
 * @author jzman
 * @param <T>
 */
class Child3<T/*,T1*/> extends GenercityEClass{
    T t;
    String t1; //子类的属性由子类决定
    @Override
    public void print(Object t) {
        //父类的属性随父类决定
        Object obj = this.name;
    }
}

/**
 * 子类和父类同时泛型擦除
 * @author jzman
 */
class Child4 extends GenercityEClass{
    //只能使用具体类型
    String str; //子类的属性由子类决定
    @Override
    public void print(Object t) {
        //父类的属性随父类决定
        Object obj = this.name;
    }
}

可以得到一些结论：父类中的属性随父类而定，子类中的属性随子类而定，子类继承父类时的方法重写，其相关的类型随父类而定，这种带有泛型的操作在继承时涉及到泛型擦除，将在下文中说明。

泛型擦除

在 泛型继承 小节中涉及到泛型的擦除，感觉比较重要，故单独记录一下，泛型擦除两种情况，具体如下：

继承或实现（接口）时泛型擦除；
具体使用时的泛型擦除。

子类继承父类时，泛型的擦除有两种情况，具体如下：

子类泛型，父类泛型擦除
子类和父类同时泛型擦除

下面是部分代码，具体如下：

/**
 * 父类泛型的擦除
 * 子类是泛型类，父类不指定类型，泛型擦除是使用Object来代替
 * @author jzman
 * @param <T>
 */
class Child3<T/*,T1*/> extends GenercityEClass{
    T t;
    String t1; //子类的属性由子类决定
    @Override
    public void print(Object t) {
        //父类的属性随父类决定
        Object obj = this.name;
    }
}

/**
 * 子类和父类同时泛型擦除
 * @author jzman
 */
class Child4 extends GenercityEClass{
    //只能使用具体类型
    String str; //子类的属性由子类决定
    @Override
    public void print(Object t) {
        //父类的属性随父类决定
        Object obj = this.name;
    }
}
/**
 * 子类擦除，父类使用泛型（错误）
 * @author jzman
 *
class Child5 extends GenercityEClass<T>{
    @Override
    public void print(T t) {
        
    }
}
 */

注意一点，不能父类泛型，子类泛型擦除，只能子类泛型在大于等于父类泛型个数的情况下才能进行泛型擦除。类实现泛型接口与类之间的继承类似，不再赘述。

下面是具体使用时的泛型擦除，具体如下：

class Child1<T> extends GenercityEClass<T>{
    T t; //子类的属性由子类决定
    @Override
    public void print(T t) {
        //父类的属性随父类决定
        T name = this.name;
    }
    
    public static void main(String[] args) {
        //1.使用时泛型擦除
        Child1 child1 = new Child1();
        Object obj = child1.name;//属性name为擦除后的类型Object
        //2.使用时指定类型
        Child1<String> child2 = new Child1();
        String name = child2.name;//属性name为指定的类型 String
    }
}

关于泛型擦除就聊到这。

泛型的高级用法

泛型的高级用法具体如下：

限制泛型可用类型
使用类型通配字符

1. 限制泛型可用类型

默认可以使用任何类型来实例化一个泛型类对象，也可以对泛型类实例的类型进行限制，语法具体如下：

//限制泛型可用类型
class <T extends AnyClass>{
    
}

上面的 AnyClass 可以是一个类也可以是一个接口，也就是说泛型的类型必须继承 AnyClass 类或实现 AnyClass 接口，无论是类还是接口，进行类型限制时都是用 extends 关键字。下面是案例，具体如下：

/**
 * 泛型可用类型限制
 * @author jzman
 */
public class LimitGenercityClass<T extends List> {
    public static void main(String[] args) {
        // T extends：<上限,T可以是上限的子类或其本身
        LimitGenercityClass<ArrayList<String>> limitClass1 = new LimitGenercityClass<>();
        LimitGenercityClass<LinkedList<String>> limitClass2 = new LimitGenercityClass<>();
        //HashMap没有实现List接口，故HashMap不能对泛型类实例的类型实例化
//        LimitGenercityClass<HashMap<String,String>> limitClass3 = new LimitGenercityClass<>();    
    }
}

上述代码中对泛型 T 进行了限制，具体的泛型类型必须实现 List 接口，ArrayList 和 LinkedList 实现了 List 接口，而 HashMap 没有实现 List 接口，所以 HashMap 不能实例化对应泛型的具体类型。

使用类型通配符

在泛型机制中提供了类型通配符，主要作用是创建一个泛型类对象时限制这个泛型类的类型继承或实现某个类或接口，可以使用？通配符来实现，同时也可以使用 extends、super 关键字对泛型进行限制，使用类型通配符语法具体如下：

//使用类型通配符
泛型类名称<? extends AnyClass> a ;

下面是类型通配符的使用，具体如下：

/**
 * 使用通配符
 * ？ extends AnyClass:限制泛型的具体类型只能是AnyClass的子类
 * ？ super AnyClass:限制泛型的具体类型只能是AnyClass的超类
 * @author jzman
 */
public class CommonCharGenercityClass<T> {
    public static void main(String[] args) {
        //1.通配符用在类型声明上
        CommonCharGenercityClass<? extends List> commA = null;
        //通配符中使用extends关键字限制了泛型只能是List的子类
        commA = new CommonCharGenercityClass<ArrayList<String>>();
        commA = new CommonCharGenercityClass<LinkedList<String>>();
//        commA = new CommonCharGenercityClass<HashMap<String>>();
        
        CommonCharGenercityClass<? super List> commB = null;
        //出错，通配符中使用super关键字限制了泛型只能是 List 的超类才可以，比如Object
//        commB = new CommonCharGenercityClass<ArrayList<String>>();
        commB = new CommonCharGenercityClass<Object>();
        
        List<String> listA = new ArrayList<>();
        listA.add("tom");
        
        List<?> listB = listA;
        //使用了通配符时，由于不确定具体类型，只能获取和删除数据，不能添加数据，不能被调用
//        listB.add("new");
        listB.remove(0);
        System.out.println(listB);    
    }
    
    //2.通配符用在方法参数上
    public static void test(CommonCharGenercityClass<? extends List> list) {
        //...
    }
}

类型通配符？可以结合关键字 extends 和 super 来实现对泛型具体类型的限制， extends 限制泛型的具体类型应该是目标类型的子类，super 限制泛型的具体类型应该是目标类型的超类，此外，类型通配符不能用在声明类上。