JavaEE-16.Java泛型详解

1.泛型概述

　　一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。

　　即“参数化类型”，首先将类型定义成参数(类似形参)，然后在使用时传入具体的类型(类似实参)，相当于把类型当参数一样传递。

　　泛型对集合类尤其有用，比如ArrayList，下面举一个刘意老师讲的事例：　　

//创建集合类
ArrayList array = new ArrayList();
//添加元素
array.add("hello");
array.add("world");
array.add("java");
array.add(10);
//定义迭代器
Iterator it = array.iterator();
//遍历
while(it.hasNext()){
    String s = (String)it.next();
    System.out.println(s);
}

上面代码的运行结果肯定会报错，原因也很明显，集合类ArrayList中添加了3个String元素和1个Integer元素，遍历的时候都转换成了String形式。

因为ArrayList可以存放任意类型，所以创建的时候并不会报错，只会有黄色的警告标志。

如果我们在一开始定义的时候就定义好类型，比如ArrayList<String> array，这样一来，添加元素的时候，如果添加Integer类型的元素就会直接报错。

就这是泛型的来由，能让我们更早的发现错误并提前做好预防。

 

2.泛型的使用

 2.1 泛型类

　　把泛型定义在类上，该类具有一个或多个类型变量。

　　格式：public class 类名<泛型类型1,...>

　　注意：1.泛型类型必须是引用类型。2.中括号中可以有几个泛型类型，但一般我们只定义一个。

　　下面还是使用刘意老师的实例，首先定义一个最基本的泛型类：　

public class ObjectTool<T> {
    private T obj;
    public T getObj() {
        return obj;
    }
    public void setObj(T obj) {
        this.obj = obj;
    }
}

上例中的这个T就相当于我们前面所说的形参，当我们实际使用的时候，可以根据我们的需要定义实际的类型，具体如下：

ObjectTool<String> ot = new ObjectTool<String>();
ot.setObj(new String("benon"));
String s = ot.getObj();
System.out.println("姓名是："+s);
        
ObjectTool<Integer> ot2 = new ObjectTool<Integer>();
ot2.setObj(new Integer(27));
Integer i = ot2.getObj();
System.out.println("年龄是："+i);

当我们将T定义为String时，此时输入的元素必须是String类型的，同理，T定义为Integer类型时也是一样的道理。

 

2.2 泛型方法

　　把泛型定义在方法上

　　格式：public < 泛型类型> 返回类型 方法名(泛型类型)

　　在泛型未出现之前，我们要输入多个类型的元素是这样的，如下代码：　

//定义工具类
public class ObjectTool{
    public void show(String s){
        System.out.println(s);
    }
    public void show(Integer i){
        System.out.println(i);
    }
    public void show(Boolean b){
        System.out.println(b);
    }
}

//定义实例类
public class ObjectToolDemo{
    public static void main(String[] args){
        ObjectTool ot = new ObjectTool();
        ot.show("hello");
        ot.show(100);
        ot.show(true);
    }
}

如上可见，因为不知道输入的类型会是什么类型，所以工具类的方法需要多次重载，类型越多，重载的方法也越多，代码变的很冗长。

因此，在JDK5版本后出现了泛型，最初的形式如下代码：

//定义工具类
public class ObjectTool<T>{
    public void show(T t){
        System.out.println(t);
    }
}
//定义实例类
public class ObjectToolDemo【
    public static void main(String[] args){
        ObjectTool<String> ot1 = new ObjectTool<String>();
        ObjectTool<Integer> ot2 = new ObjectTool<Integer>();
        ObjectTool<Boolean> ot3 = new ObjectTool<Boolean>();

        ot1.show("hello");
        ot2.show(100);
        ot3.shwo(true);
    }
}

上面的代码中，工具类变的简单了，但实例类却重复代码过多，且工具类也必须定义为泛型类，因此我们又想到了下面更简便的方法：

//定义工具类，该类不是泛型的，而是将泛型定义在方法上
public class ObjectTool {
    public <T> void show(T t) {
        System.out.println(t);
    }
}

//定义实例类
public class ObjectToolDemo {
    public static void main(String[] args) {
        ObjectTool ot = new ObjectTool();
        
        ot.show("hello");
        ot.show(100);
        ot.show(true);
    }
}

由上面的代码可看出，因为泛型在方法上，show()方法接受的参数是什么类型，输出的结果就会是什么类型，这样一来，方法就可以接受任意类型。

 

2.3 泛型接口

　　把泛型定义在接口上

　　格式：public interface 接口名 <泛型类型1,...>

　　首先，定义一个泛型接口，如下代码：

public interface Inter<T> {
    public abstract void show(T t);
}

　　其次，当实现接口的类，未传入泛型实参时，如下代码：　

public class InterImpl<T> implements Inter<T>{
    @Override
    public void show(T t) {
        // TODO 自动生成的方法存根
        System.out.println(t);
    }    
}

　　最后，当实现接口的类，传入泛型实参时，如下代码：

public class InterDemo {
    public static void main(String[] args) {
        Inter<String> i = new InterImpl<String>();
        Inter<Integer> ii = new InterImpl<Integer>();
        
        i.show("hello");
        ii.show(100);
    }
}

 

　3. 泛型通配符　

//定义一个父类和两个子类
class Animal{
    
}
class Dog extends Animal{
    
}
class Cat extends Animal{
    
}

　　3.1 无界通配符

　　　　？：任意类型，如果没有明确，那么就是Object以及任意的Java类

        Collection<?> c2 = new ArrayList<Object>();
        Collection<?> c3 = new ArrayList<Animal>();
        Collection<?> c4 = new ArrayList<Dog>();
        Collection<?> c5 = new ArrayList<Cat>();

　　3.2 上界通配符

　　　　？ extends E：向下限定，E及其子类

    Collection<? extends Animal> c6 = new ArrayList<Animal>();
    Collection<? extends Animal> c7 = new ArrayList<Dog>();
    Collection<? extends Animal> c8 = new ArrayList<Cat>();

　　3.3 下界通配符

　　　　？ super E：向上限定，E及其父类

    Collection<? super Animal> c9 = new ArrayList<Animal>();
    Collection<? super Dog> c10 = new ArrayList<Animal>();
    Collection<? super Cat> c11 = new ArrayList<Animal>();