Java核心技术梳理-泛型

1、引言

在学习集合的时候咱们会发现一个问题，将一个对象丢到集合中后，集合并不记住对象的类型，通通都当作Object处理，这样咱们取出来再使用时就得强制转换类型，致使代码臃肿，并且加入集合时都是以Object，没作类型检查，那么强制转换就容易出错，泛型的诞生就是为解决这些问题。

2、使用泛型

泛型是如何解决这个问题呢？按照上面的问题，咱们只须要在建立集合时指定集合元素的类型，那么集合就能记住对象的类型，那当咱们加入是就只能按照指定的类型进行加入，而取出使用时也不须要强制转换：

ArrayList<Integer> list = new ArrayList<Integer>();

这是Java 7以前的写法，很明显构造器上面的泛型没有必要，如今推荐如下写法：

ArrayList<Integer> list = new ArrayList<>();

既然我已经指定了类型，那么添加时只能添加Integer，而且使用时能够直接当作Integer使用

System.out.println(list.get(2)+3);

这种参数化类型就是泛型，泛型就是容许在定义类、接口、方法时使用类型形参，这个参数形参将在申明变量、建立对象、调用方法时动态指定。

3、 定义泛型接口、类

来看看List接口和Map接口的定义：

public interface List<E> extends Collection<E>
public interface Map<K,V>

List接口定义时指定了一个类型形参，Map接口定义了两个类型形参。接口定义了形参以后，在接口中形参就能够当作一种类型来使用，那么其中的方法就可使用类型形参

boolean add(E e);

这种方式其实也是一种代码复用，咱们经过类型形参，高度的将参数抽象，而不须要每种类型都去从新定义类，只要在使用时肯定类型便可。咱们也能够自定义泛型类

public class WebResult<T> {
    //使用T类型形参定义实例变量
    private T data;

    public WebResult() {
    }
    //使用T类型形参构造对象
    public WebResult(T data) {
        this.data = data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public T getData() {
        return this.data;
    }

    public static void main(String[] args) {
        WebResult<String> webResult = new WebResult<>("返回一个String对象");
        System.out.println(webResult.getData());
        WebResult<Integer> webResult1 = new WebResult<>(10);
        System.out.println(webResult1.getData());
    }

}

4、通配符

先看下面这段代码：

public static void main(String[] str){
    ArrayList<String> arrayList=new ArrayList();
    test(arrayList);
}

public static void test(List<Object> test){
    for (int i = 0; i <test.size() ; i++) {
        System.out.println(test.get(i));
    }
}

这段代码会出现编译错误，由于List<String>对象不能做为List<Object>使用，这说明泛型不是协变的，由于以前数组的设计是协变的，致使存在安全性问题，而泛型的设计原则是编译时不出现警告就不会出现类型转换错误，那为了表示各类泛型的父类，就引入了通配符：？这个问号表明能够是匹配任何类型。

将方法修改：

public static void test(List<?> test){
    for (int i = 0; i <test.size() ; i++) {
        System.out.println(test.get(i));
    }
}

这样即可以顺利编译，咱们再加上这段代码：

public static void main(String[] str){
    ArrayList<String> arrayList=new ArrayList();
    test(arrayList);
    List<?> strings = arrayList;
    strings.add("abc");
}

这里咱们能够将arrayList给strings，按说这个时候是不能赋值的，由于List不知道类型参数的值，这是编译器做用，能够进行类型推理，可是后面的strings.add("abc")是不能经过编译的，编译器不能对 List 的类型参数做出足够严密的推理，以肯定将 String 传递给 List.add() 是类型安全的。因此编译器将不容许这么作。

4.1 设置通配符上限

List<?>这种方式，通配的是全部的类型，不少时候咱们能够肯定是哪一类对象能够添加进去，咱们只但愿它表明某一类泛型的父类，这个时候咱们能够设置通配符的上限。

//动物类
public abstract class Animal {
    public abstract void say();
}

public class Cat extends Animal {
    @Override
    public void say() {
        System.out.println("喵喵");
    }
}

public class Dog extends Animal {

    @Override
    public void say() {
        System.out.println("旺旺");
    }
}

这个时候咱们就限定了上限

public static void test1(List<? extends Animal> animals) {
    for (int i = 0; i < animals.size(); i++) {
        animals.get(i).say();
    }
}

咱们也能够直接在定义类型形参的时候设置上限

public class WebResult<T extends Animal> {

4.2 通配符下限

既然有设置上限，那也有设置下限，那在什么状况下会使用下限呢？看个例子

//将src中的集合复制到dest，并返回最后一个值
public static <T> T copy(Collection<T> dest, Collection<? extends T> src) {
    T last = null;
    for (T ele : src) {
        last = ele;
        dest.add(ele);
    }
    return last;
}

功能比较很简单，将src中的集合复制到dest，并返回src最后一个值

List<Number> ln = new ArrayList<>();
List<Integer> li = new ArrayList<>();
//编译出错，类型不肯定
Integer last = copy(ln, li);

这个时候出错，由于虽然咱们知道返回的值必定是Integer，可是因为copy方法的返回值并非，全部至关于咱们在复制的过程当中丢失了src的类型，若是咱们想定义约束关系使得返回值明确即：dest集合元素类型与src的关系要么相同要么是其父类，为了表示这种约束关系，引入了<? super T> 这个通配符表示它必须是T自己或者T的父类。

//将src中的集合复制到dest，并返回最后一个值
public static <T> T copy(Collection<? super T> dest, Collection<? extends T> src) {
    T last = null;
    for (T ele : src) {
        last = ele;
        dest.add(ele);
    }
    return last;
}

5、泛型方法

除了泛型接口和泛型类，咱们还能够定义泛型方法，写法以下：

static <T> void arrayToList(T[] a, List<T> list) {
    for (T o : a) {
        list.add(o);
    }
}

调用以下：

Object[] objects = new Object[10];
List<Object> list = new ArrayList<>();
arrayToList(objects, list);

Integer[] integers = new Integer[10];
List<Integer> integerList = new ArrayList();
arrayToList(integers, integerList);

String[] strings = new String[10];
List<String> stringList = new ArrayList<>();
arrayToList(strings, stringList);
//编译错误，类型不正确
arrayToList(strings, integerList);

这里能够看出泛型方法跟类型通配符的功能有点相似，其实在大部分状况下咱们能够用泛型方法代替类型通配符。

泛型方法容许类型形参被用来表示方法的一个或者多个参数之间的依赖关系，或者说与返回值之间的关系，若是没有这种关系，咱们就不使用泛型方法。

6、擦除与转换

当把一个具备泛型信息的对象赋给一个没有泛型信息的变量时，全部的类型信息就都丢掉了，好比List<String>类型被转换成List,则对该List的类型检查也变成了Object。

public class WebResult<T extends Number> {
    //使用T类型形参定义实例变量
    private T data;

    public WebResult() {
    }

    //使用T类型形参构造对象
    public WebResult(T data) {
        this.data = data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public T getData() {
        return this.data;
    }

    public static void main(String[] args) {
        WebResult<Integer> webResult1 = new WebResult<>(10);
        System.out.println(webResult1.getData());
        WebResult<Integer> a = new WebResult<>(20);
        WebResult b = a;
        //已经擦除了泛型，只能按最高类型Object
        //Integer bData = b.getData();
        Object object=b.getData();
    }

}

本来的泛型类上限是Number，而当把a赋给擦除泛型的b对象时，编译器失去了推断能力，只能把其当作Objec来处理。

而当一个List转成泛型对象是java是容许的

List<Integer> integerList = new ArrayList<>();
List stringList = integerList;
//容许直接将list对象转换给
List<String> strings = stringList;
//直接获取数据会出现错误，由于转换不成功
System.out.println(stringList.get(0));