3、实现泛型特性构件

面向对象的一个重要目标是对代码重用的支持。支持这个目标的一个重要的机制就是泛型机制(generic mechanism):例如：可以编写一个方法，将由一些对象组成的数组排序，方法的逻辑关系与被排序的对象的类型无关，此时可以使用泛型方法。

1. 使用Object模拟表示泛型

    public static void main(String[] args) {
        Integer[] ints = {1,4,7,3,2};
        String[] strings = {"-a-","-c-","-ss-","-ds-","-e-"};
        sort(ints);
        sort(strings);
    }

    public static void sort(Object[] arr){
        Arrays.stream(arr).forEach(x -> System.out.print(x));
        Arrays.sort(arr);
        System.out.printf("\n");
        Arrays.stream(arr).forEach(x -> System.out.print(x));
    }

缺陷

不能使用基本类型的，（可以使用包装类）。

只能使用Object类中的方法，局限性非常大。

补充

数组是协变性的。例如Employ和Student都是Person。

Person[] arr = new Employ[5];
arr[0] = new Student();

编译通过，但是运行时，抛出ClassCastException异常,因为Student is not a Employ。java中数组是类型兼容的，这叫做协变数组类型，但是集合Collection不是协变的。

2.简单的泛型类

//类的声明包含一个或多个参数，放在类名后的尖括号。
public class Generic <T>{

    private T anyType;

    public void write(T anyType){
        this.anyType = anyType;
    }

    public T read(){
        return anyType;
    }

}

3.带有限制的通配符。

Circle 继承了Shape

    public static void main(String[] args) {
        List<Shape> shapes = new ArrayList<>();
        List<Circle> circles = new ArrayList<>();
        printTotalArea(shapes);
        //printTotalArea(circles);
    }
    //计算总面积
    public static void printTotalArea(Collection<Shape> collection){

        double sum = 0;

        for (Shape shape : collection) {
            sum = + shape.area();
        }

        System.out.println(sum);
    }

因为Collections不是协变的,必须传入Collection中的Shape类型，所以当传入circles会报错。

java5中的通配符可以弥补这个不足。

Collection

4.类型限界

写一个找最大对象的方法

    public static <T> T findMax(T[] arr){
        int maxIndex = 0;
        for (int i = 1; i < arr.length; i++) {
            if(arr[i].compareTo(arr[maxIndex])>0){
                maxIndex = i;
            }
        }
        return arr[maxIndex];
    }

因为传入的类型不一定实现Comparable接口，所以arr[i].compareTo(arr[maxIndex])会报错，只有当T is a Comparable的情况下才能正常调用。就可以使用类型限界来解决。
改下如下：

    public static <T extends Comparable>

但是更好的做法是

    //进一步限制比较的类型
    public static <T extends Comparable<T>>

但是这样做仍然有问题，
假设有Shape类，实现了Comparable，Circle类继承了Shape;这时候Circle is a Comparable,但是Circle is not a Comparable;解决这个问题只要使用通配符就可以了。改写如下：

public static <T extends Comparable<? super T>>

看着有点乱，幸运的是，这基本是这种用语最复杂的用语了。

5.类型擦除

首先推荐一篇博客类型擦除,说的很好。

Java的泛型是伪泛型，code的过程泛型信息是存在的，对我们写的代码进行检查，而在编译之后，所有的泛型信息会被擦除掉(反编译还是存在的，但是运行就不存在了)。

一个简单的示例

    public static void main(String[] args) {  
        ArrayList<String> arrayList1=new ArrayList<String>();  
        arrayList1.add("abc");  
        ArrayList<Integer> arrayList2=new ArrayList<Integer>();  
        arrayList2.add(123);  
        System.out.println(arrayList1.getClass()==arrayList2.getClass());  
    }
    //true

在这个例子中，我们定义了两个ArrayList数组，不过一个是ArrayList泛型类型，只能存储字符串。一个是ArrayList泛型类型，只能存储整形。最后，我们通过arrayList1对象和arrayList2对象的getClass方法获取它们的类的信息，最后发现结果为true。说明泛型类型String和Integer都被擦除掉了，只剩下了原始类型。

原始类型（raw type）就是擦除去了泛型信息，最后在字节码中的类型变量的真正类型。无论何时定义一个泛型类型，相应的原始类型都会被自动地提供。类型变量被擦除（crased），并使用其限定类型（无限定的变量用Object）替换。

class Pair<T> {  
    private T value;  
    public T getValue() {  
        return value;  
    }  
    public void setValue(T  value) {  
        this.value = value;  
    }  
} 
//原始类型
class Pair {  
    private Object value;  
    public Object getValue() {  
        return value;  
    }  
    public void setValue(Object  value) {  
        this.value = value;  
    }
}

如果类型变量有限定，那么原始类型就用第一个边界的类型变量来替换。
比如Pair这样声明

public class Pair<T extends Comparable& Serializable> 

那么原始类型就是Comparable

如果Pair这样声明public class Pair<T extends Serializable&Comparable> ，那么原始类型就用Serializable替换

如果使用一个泛型类而不带类型参数，那么使用的就是原始类。

限制

1. 不能使用基本类型
2. instanceOf检测，因为被擦出了，所以同一个泛型类都是true;
3. static 方法和static域不可引用类的类型变量；（都被擦除了还怎么引用）
4. 不能创建泛型数组

T[] arr = new T[10]

T将由他的限界代替，可能是Object或者是抽象类什么的。
5. 参数化类型的数组

public static void main(String[] args) {
        //写这句话ide就提示错误，Generic array creation
        AreaTest<String> [] arr1 = new AreaTest<String>[10];
        AreaTest<Double> area = new AreaTest<Double>());
        Object[] objects = arr1;
        objects[0] = area;
        String s = arr1[0].read();
    }

类型擦除之后，都是AreaTest，所以是可以添加的，但是arr1[0].read()的时候产生一个ClassCastException,这是泛型应该避免的情况。