Java编程思想学习(十一)泛型

 1.概要

generics enable types (classes and interfaces) to be parameters when defining classes, interfaces and methods.

泛型能在定义类，接口和方法时将类型（类和接口）作为参数。和方法声明时的形式参数很类似，都是为了在不同的输入时重用相同的代码。不同的是形式参数输入的是值而泛型是类型。

2.为什么使用泛型

1.编译时更加强的(Stronger)类型检测
java编译器对泛型代码进行强类型检测，一旦检测到代码违反类型安全就发出类型错误。
修复编译错误要比运行错误容易，因为运行错误很难找到问题所在。

2.不用类型转换

       //没有使用泛型
        List list = new ArrayList();
        list.add("without generics");
        //需要强制类型转换
        String s1 = (String) list.get(0);
        
        //使用泛型
        List<String> list2 = new ArrayList<String>();
        list2.add("generics");
        String s2 = list2.get(0);//不需要转换

3.使程序员能实现适用更加普遍的算法

通过使用泛型，使程序员能实现普遍的算法，算法将是能使用于不同类型的，能自定义的，类型安全的，易读的。

如只写一个排序方法，就能够对整形数组、字符串数组甚至支持排序的任何类型的数组进行排序。

3.具体使用

1.泛型（generic type）

A generic type is a generic class or interface that is parameterized over types.

泛型是一种通用的类或接口，通过类型参数化的。

泛型类以下面的格式定义：

class name<T1, T2, ..., Tn> { /* ... */ }

通过Box类的非泛型版和泛型版来学习一下：

非泛型：

//non-generic class
public class Box {
    private Object object;

    public Object getObject() {
        return object;
    }

    public void setObject(Object object) {
        this.object = object;
    }
}

泛型：

//generic class
public class Box<T> {

    //T表示Type
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

}

类型参数命名规范按约定的习俗，类型参数的名字都是由一个大写字母构成。

E - Element 元素(used extensively by the Java Collections Framework)
K - Key 键
N - Number 数值
T - Type 类型
V - Value 值
S,U,V etc. - 2nd, 3rd, 4th types 第二种，第三种，第四种类型

调用和实例化泛型类

为了获得泛型类的引用，必须执行泛型类的调用，使用具体的值来代替T，如Integer。

//获得引用
Box<Integer> integerBox;
//实例化
integerBox = new Box<Integer>();

泛型类的调用类似于普通的方法调用，只是泛型类传递的是类型参数（type argument）而方法调用传递的是参数(argument)。

多类型参数

泛型类可能有多种类型的参数。如下所示：

public interface Pair>{
    public K getKey();
    public V getValue();
}
public class OrderedPair> implements Pair>{
    private K key;
    private V value;
    public OrderedPair(K key,V value){
        this.key = key;
        this.value = value;
    }
    @Override
    public K getKey() {
        return key;
    }

    @Override
    public V getValue() {
        return value;
    }
}
//实例化
Pair<String, Integer> p1 = new OrderedPair<String, Integer>("Even", 8);
Pair<String, String>  p2 = new OrderedPair<String, String>("hello", "world");
//Java SE7开始出现的新语法
OrderedPair<String, Integer> p1 = new OrderedPair<>("Even", 8);
OrderedPair<String, String>  p2 = new OrderedPair<>("hello", "world");
//参数化的类型
OrderedPair<String, Box<Integer>> p = new OrderedPair<>("primes", new Box<Integer>(...));

4.类型擦除

(1)什么事类型擦除？

类型擦除指的是通过类型参数合并，将泛型类型实例关联到同一份字节码上。编译器只为泛型类型生成一份字节码，并将其实例关联到这份字节码上。类型擦除的关键在于从泛型类型中清除类型参数的相关信息，并且再必要的时候添加类型检查和类型转换的方法。
类型擦除可以简单的理解为将泛型java代码转换为普通java代码，只不过编译器更直接点，将泛型java代码直接转换成普通java字节码。
类型擦除的主要过程如下：
1.将所有的泛型参数用其最左边界（最***的父类型）类型替换。
2.移除所有的类型参数。
如：

 1 interface Comparable  { 
 2   public int compareTo( A that); 
 3 } 
 4 final class NumericValue implements Comparable  { 
 5   priva te byte value;  
 6   public  NumericValue (byte value) { this.value = value; }  
 7   public  byte getValue() { return value; }  
 8   public  int compareTo( NumericValue t hat) { return this.value - that.value; } 
 9 } 
10 －－－－－－－－－－－－－－－－－
11 class Collections {  
12   public static extends Comparable>A max(Collection  xs) { 
13     Iterator  xi = xs.iterator(); 
14     A w = xi.next(); 
15     while (xi.hasNext()) { 
16       A x = xi.next(); 
17       if (w.compareTo(x) <0) w = x; 
18     } 
19     return w; 
20   } 
21 } 
22 final class Test { 
23   public static void main (String[ ] args) { 
24     LinkedList  numberList = new LinkedList  (); 
25     numberList .add(new NumericValue((byte)0));  
26     numberList .add(new NumericValue((byte)1));  
27     NumericValue y = Collections.max( numberList );  
28   } 
29 }
30 

 1   public int compareTo( Object that); 
 2 } 
 3 final class NumericValue implements Comparable { 
 4   priva te byte value;  
 5   public  NumericValue (byte value) { this.value = value; }  
 6   public  byte getValue() { return value; }  
 7   public  int compareTo( NumericValue t hat)   { return this.value - that.value; } 
 8   public  int compareTo(Object that) { return this.compareTo((NumericValue)that);  } 
 9 } 
10 －－－－－－－－－－－－－
11 class Collections {  
12   public static Comparable max(Collection xs) { 
13     Iterator xi = xs.iterator(); 
14     Comparable w = (Comparable) xi.next(); 
15     while (xi.hasNext()) { 
16       Comparable x = (Comparable) xi.next(); 
17       if (w.compareTo(x) <0) w = x; 
18     } 
19     return w; 
20   } 
21 } 
22 final class Test { 
23   public static void main (String[ ] args) { 
24     LinkedList numberList = new LinkedList(); 
25     numberList .add(new NumericValue((byte)0));  ，
26     numberList .add(new NumericValue((byte)1));  
27     NumericValue y = (NumericValue) Collections.max( numberList );  
28   } 
29 }
30 

第一个泛型类Comparable 擦除后 A被替换为最左边界Object。Comparable的类型参数NumericValue被擦除掉，但是这直 接导致NumericValue没有实现接口Comparable的compareTo(Object that)方法，于是编译器充当好人，添加了一个桥接方法。
第二个示例中限定了类型参数的边界>A，A必须为Comparable的子类，按照类型擦除的过程，先讲所有的类型参数 ti换为最左边界Comparable，然后去掉参数类型A，得到最终的擦除后结果。

 1   public class Erasure{  
 2   
 3             public void test(List ls){  
 4                 System.out.println("Sting");  
 5             }  
 6             public void test(List li){  
 7                 System.out.println("Integer");  
 8             }  
 9     }  
10 

 1 import java.util.*;
 2 
 3 public class StaticTest{
 4     public static void main(String[] args){
 5         GT gti = new GT();
 6         gti.var=1;
 7         GT gts = new GT();
 8         gts.var=2;
 9         System.out.println(gti.var);
10     }
11 }
12 class GT{
13     public static int var=0;
14     public void nothing(T x){}
15 }
16