java 范型 约束

 

转自：

http://www.myexception.cn/mobile/692129.html

向作者致谢！

 

----------------------------------------------------------------------------------------------------------------------------------------------------------------------

大多数这些需要注意的问题，都是由类型擦除引起的。

一、基本类型

不能用类型参数替换基本类型。就比如，没有ArrayList<double>，只有ArrayList<Double>。因为当类型擦除后，ArrayList的原始类型变为Object，但是Object类型不能存储double值，只能引用Double的值。

 

二、运行时类型查新

举个例子:

 

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

因为类型擦除之后，ArrayList<String>只剩下原始类型，泛型信息String不存在了。

 

那么，运行时进行类型查询的时候使用下面的方法是错误的

 

if( arrayList instanceof ArrayList<String>)

java限定了这种类型查询的方式

 

 

if( arrayList instanceof ArrayList<?>)

三、异常

1、不能抛出也不能捕获泛型类的对象。事实上，泛型类扩展Throwable都不合法。例如：下面的定义将不会通过编译：

 

public class Problem<T> extends Exception{......}

为什么不能扩展Throwable，因为异常都是在运行时捕获和抛出的，而在编译的时候，泛型信息全都会被擦除掉，那么，假设上面的编译可行，那么，在看下面的定义：

 

 

try{
}catch(Problem<Integer> e1){
。。
}catch(Problem<Number> e2){
...
} 

类型信息被擦除后，那么两个地方的catch都变为原始类型Object，那么也就是说，这两个地方的catch变的一模一样,就相当于下面的这样

 

 

try{
}catch(Problem<Object> e1){
。。
}catch(Problem<Object> e2){
...

这个当然就是不行的。就好比，catch两个一模一样的普通异常，不能通过编译一样：

 

 

try{
}catch(Exception e1){
。。
}catch(Exception  e2){//编译错误
...

 

2、不能再catch子句中使用泛型变量

 

public static <T extends Throwable> void doWork(Class<T> t){
        try{
            ...
        }catch(T e){ //编译错误
            ...
        }
   }

因为泛型信息在编译的时候已经变味原始类型，也就是说上面的T会变为原始类型Throwable，那么如果可以再catch子句中使用泛型变量，那么，下面的定义呢：

 

 

public static <T extends Throwable> void doWork(Class<T> t){
        try{
            ...
        }catch(T e){ //编译错误
            ...
        }catch(IndexOutOfBounds e){
        }                         
 }

，根据异常捕获的原则，一定是子类在前面，父类在后面，那么上面就违背了这个原则。即使你在使用该静态方法的使用T是ArrayIndexOutofBounds，在编译之后还是会变成Throwable，ArrayIndexOutofBounds是IndexOutofBounds的子类，违背了异常捕获的原则。所以java为了避免这样的情况，禁止在catch子句中使用泛型变量。

 

 

但是在异常声明中可以使用类型变量。下面方法是合法的。

 

   public static<T extends Throwable> void doWork(T t) throws T{
       try{
           ...
       }catch(Throwable realCause){
           t.initCause(realCause);
           throw t; 
       }
  }

上面的这样使用是没问题的。

 

 

四、数组

不能声明参数化类型的数组。如：

  Pair<String>[] table = newPair<String>(10); //ERROR

   这是因为擦除后，table的类型变为Pair[]，可以转化成一个Object[]。
  

Object[] objarray =table;

  数组可以记住自己的元素类型，下面的赋值会抛出一个ArrayStoreException异常。
   

objarray ="Hello"; //ERROR

  对于泛型而言，擦除降低了这个机制的效率。下面的赋值可以通过数组存储的检测，但仍然会导致类型错误。  

 objarray =new Pair<Employee>();

 

提示：如果需要收集参数化类型对象，直接使用ArrayList：ArrayList<Pair<String>>最安全且有效。

 

五、泛型类型的实例化 

不能使用像new T(...)，new T[...]，T.class这样的表达式

不能实例化泛型类型。如，

 

    first = newT(); //ERROR

   是错误的，类型擦除会使这个操作做成new Object()。

   可以使用Class.newInstance()方法：

    cl.newInstanc();
   不能建立一个泛型数组。
  

  public<T> T[] minMax(T[] a){
       T[] mm = new T[2]; //ERROR
       ...
  }

   类似的，擦除会使这个方法总是构靠一个Object[2]数组。但是，可以用反射构造泛型对象和数组。
   利用反射，调用Array.newInstance:

 

 publicstatic <T extends Comparable> T[]minmax(T[] a)

    {

       T[] mm == (T[])Array.newInstance(a.getClass().getComponentType(),2);

        ...

       // 以替换掉以下代码

       // Obeject[] mm = new Object[2];

       // return (T[]) mm;

    }

 

六、静态上下文

  不能在静态域或者方法中引用类型变量。

 

public class Test<M> {

public static void test(M m) {  //error

}
} 

这句话的错误提示是无法在静态上下文中引用非静态类 M.
因为test方法是静态的可以用类名直接调用,而M只有在类Test创建对象的时候才会明确.
test静态方法存在的时候还没明确M是什么.
所以静态方法不可以访问类上定义的泛型.
如果静态方法操作的引用数据类型不确定,可以将泛型定义在方法上.
可以改成:

 

public class Test {

public static <M> void test(M m) {  //right

}
} 

 

 

 
  七、类型擦除后的冲突

1、

当泛型类型被擦除后，创建条件不能产生冲突。如果在Pair类中添加下面的equals方法：

 

class Pair<T>   {
	public boolean equals(T value) {
		return null;
	}
	
}

考虑一个Pair<String>。从概念上，它有两个equals方法：

 

booleanequals(String); //在Pair<T>中定义

boolean equals(Object); //从object中继承

但是，这只是一种错觉。实际上，擦除后方法

booleanequals(T)

变成了方法 booleanequals(Object)

这与Object.equals方法是冲突的！当然，补救的办法是重新命名引发错误的方法。

 

2、

泛型规范说明提及另一个原则“要支持擦除的转换，需要强行制一个类或者类型变量不能同时成为两个接口的子类，而这两个子类是同一接品的不同参数化。”

下面的代码是非法的：

class Calendar implements Comparable<Calendar>{ ... }

class GregorianCalendar extends Calendar implements Comparable<GregorianCalendar>{...} //ERROR

GregorianCalendar会实现Comparable<Calender>和Compable<GregorianCalendar>，这是同一个接口的不同参数化实现。

 

这一限制与类型擦除的关系并不很明确。非泛型版本：

 

class Calendar implements Comparable{ ... }

class GregorianCalendar extends Calendar implements Comparable{...} //ERROR

是合法的。

有可能与合成的桥方法产生冲突有关：

public int compareTo(Object other) {return compareTo((X) other);}

方法体产生冲突，X应是Calender还是GregorianCalendar，不确定

 

 

八、泛型中 参数化类型不考虑继承关系

 

ArrayList<String> arrayList1=new ArrayList<Object>();//编译错误
ArrayList<Object> arrayList1=new ArrayList<String>();//编译错误