java泛型

参考博客：https://blog.csdn.net/lonelyroamer/article/details/7868820#

1.类型参数的好处

在 java 增加泛型类之前，泛型程序设计是用继承实现的

ArrayList

public class ArrayList{
    
    private Object elementData;
    ...
    public Object get(int id);
    public void add(int i);
}

但是这种方法有两个问题

• 当获取一个值时，必须进行强制类型转换

ArrayList list = new ArrayList();
String name = (String)list.get(0);

• 没有错误检查，可以向数组列表中添加任何类的对象

list.add(new File("...."));

泛型提供了一个更好的解决方案：类型参数，用来指定元素的类型

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

这使得代码具有更好的可读性，人们一看就知道列表中包含String对象

优点

• java SE7后，可以省略泛型类型：ArrayList files = new ArrayList(); 省略的类型可以从变量类型推断出来
• get() 对象的时候不用进行类型转化，就知道返回的是什么类型
• list.add( new File()); 是无法编译通过的，出现编译错误比类在运行时出现类的强制转化异常要好得多

2.定义简单的泛型类

public class Pair<T>{
    
    private T first;
    private T second;
    ....
    
}

Pair 中引入一个类型变量T，用<>括起来，并放在类后面

3.泛型方法

• 泛型方法可以定义在 普通类 、 泛型类中
• 泛型参数声明放在返回值 T 之前

public class ArrUtils {

    public static <T> T getMiddle(T ... arr){
        return arr[arr.length/2];
    }
}

当调用一个泛型方法的时候，在方法名前放入具体的参数

String middle = ArrAlg.<String>getMiddle("a","B","C");

实际上，这种情况可以省略,编译器有足够的信息推断出所调用方法的具体参数，因为"a"，“b","c"是String类型，所以可以推断出也是String

参数类型提升

 @Test
    public void test01(){
        Double middle = ArrUtils.getMiddle(1, 2.3, 3);
        System.out.println(middle);
    }

上面会报错，1 会提升为 Integer，2.3 提升为Dubbo ，两者的最小基类为 Number，所以middle 的类型应为 Number

Error:(19, 43) java: 不兼容的类型: 推断类型不符合上限
    推断: java.lang.Number&java.lang.Comparable<? extends java.lang.Number&java.lang.Comparable<?>>
    上限: java.lang.Double,java.lang.Object

4.类型变量限定

有时候类或者方法需要对类型参数进行限定，下面是一个典型的例子

public class ArrAlg{
    public static<T> T min(T[] a){
        if(a==null || a.length ==0 ) return null;
        T smin = a[0];
        for(int i=0; i<a.length; i++){
            if(smin.compareTo( a[i]) ){
                smin = a[i];
            }
        }
    }
}

上面有一个问题，导致编译通不过，就是怎么确保所有 T 类型，都有 compareTo() 方法呢，所以给 T 加上限定

public static<T extends Compareable > T min(T[] a);

虽然 Comprable 是接口，但这里用的关键字是 extends , 而不是implements 这是 jdk 定义的

<T extends BoundingType > 

表示 T 应该是绑定类型的子类型，T 和绑定类型可以是类，也可以是接口

一个或者多个变量通配符可以有多个限定，用 & 分割

<T extends Comparable & Serializable >

5.泛型擦除

Java的泛型是伪泛型。为什么说Java的泛型是伪泛型呢？因为，在编译期间，所有的泛型信息都会被擦除掉。正确理解泛型概念的首要前提是理解类型擦出（type erasure）。

Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会在编译器在编译的时候去掉。这个过程就称为类型擦除。

如在代码中定义的List和List等类型，在编译后都会编程List。JVM看到的只是List，而由泛型附加的类型信息对JVM来说是不可见的( 在生成字节码时，已经擦除了参数，JVM对泛型信息不可见）。Java编译器会在编译时尽可能的发现可能出错的地方，但是仍然无法避免在运行时刻出现类型转换异常的情况。

• 例1；

public class Test4 {
	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());
	}
}

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

• 例2；

public class Test4 {
	public static void main(String[] args) throws IllegalArgumentException, SecurityException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
		ArrayList<Integer> arrayList3=new ArrayList<Integer>();
		arrayList3.add(1);//这样调用add方法只能存储整形，因为泛型类型的实例为Integer
		arrayList3.getClass().getMethod("add", Object.class).invoke(arrayList3, "asd");
		for (int i=0;i<arrayList3.size();i++) {
			System.out.println(arrayList3.get(i));
		}
	}

在程序中定义了一个ArrayList泛型类型实例化为Integer的对象，如果直接调用add方法，那么只能存储整形的数据。不过当我们利用反射调用add方法的时候，却可以存储字符串。这说明了Integer泛型实例在编译之后被擦除了，只保留了原始类型。

5.1 类型擦除后保留的原始类型

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

class Pair<T> {
    private T value;
    public T getValue() {
        return value;
    }
    public void setValue(T  value) {
        this.value = value;
    }
}

Pair的原始类型为：

class Pair {
	private Object value;
	public Object getValue() {
		return value;
	}
	public void setValue(Object  value) {
		this.value = value;
	}

因为在Pair中，T是一个无限定的类型变量，所以用Object替换。其结果就是一个普通的类，如同泛型加入java变成语言之前已经实现的那样。在程序中可以包含不同类型的Pair，如Pair或Pair，但是，擦除类型后它们就成为原始的Pair类型了，原始类型都是Object。
从上面的那个例2中，我们也可以明白ArrayList被擦除类型后，原始类型也变成了Object，所以通过反射我们就可以存储字符串了。

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

public class Pair<T extends Comparable& Serializable> {  }

注意

如果Pair这样声明public class Pair<T extends Serializable&Comparable> ，那么原始类型就用Serializable替换，而编译器在必要的时要向Comparable插入强制类型转换。为了提高效率，应该将标签（tagging）接口（即没有方法的接口）放在边界限定列表的末尾。

5.2要区分原始类型和泛型变量的类型

在调用泛型方法的时候，可以指定泛型，也可以不指定泛型。

在不指定泛型的情况下，泛型变量的类型为 该方法中的几种类型的同一个父类的最小级，直到Object。

在指定泛型的时候，该方法中的几种类型必须是该泛型实例类型或者其子类。

public class Test2{
	public static void main(String[] args) {
		/**不指定泛型的时候*/
		int i=Test2.add(1, 2); //这两个参数都是Integer，所以T为Integer类型
		Number f=Test2.add(1, 1.2);//这两个参数一个是Integer，以风格是Float，所以取同一父类的最小级，为Number
		Object o=Test2.add(1, "asd");//这两个参数一个是Integer，以风格是Float，所以取同一父类的最小级，为Object
 
                /**指定泛型的时候*/
		int a=Test2.<Integer>add(1, 2);//指定了Integer，所以只能为Integer类型或者其子类
		int b=Test2.<Integer>add(1, 2.2);//编译错误，指定了Integer，不能为Float
		Number c=Test2.<Number>add(1, 2.2); //指定为Number，所以可以为Integer和Float
	}
	
	//这是一个简单的泛型方法
	public static <T> T add(T x,T y){
		return y;
	}
}

其实在泛型类中，不指定泛型的时候，也差不多，只不过这个时候的泛型类型为Object，就比如ArrayList中，如果不指定泛型，那么这个ArrayList中可以放任意类型的对象。

public static void main(String[] args) {
		ArrayList arrayList=new ArrayList();
		arrayList.add(1);
		arrayList.add("121");
		arrayList.add(new Date());
	}