Thinking in Java 泛型

介绍

一般的类和方法,只能使用具体的类型:要么是基本类型,要么是自定义的类。如果要编写可以应用于多种类型的代码,这种刻板的限制对代码的束缚就会很大。在Java SE5中提出了泛型的概念。泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。

优点

1)类型安全:提高Java程序的类型安全,通过知道使用类型定义的变量的类型限制,将运行时期的类转换异常体现在编译时期;

2)消除强制类型转换:消除源代码中的许多强制类型转换,这使得代码更加可读,并且减少了出错机会

3)潜在的性能收益:泛型为较大的优化带来可能。在泛型的初始实现中,编译器将强制类型转换(如果没有泛型的话,程序员会指定这些强制类型转换)插入生成的字节码中。但是更多类型信息可用于编译器这一事实,为未来版本的JVM优化带来可能。由于泛型的实现方式,支持泛型(几乎)不需要JVM或类文件更改。所有工作都在编译器中完成,编译器生成类似于没有泛型(和强制类型转换)时缩写的代码,只是更能确保类型安全而已。


简单泛型

下面的例子没有采用泛型的概念,通过根类object类来强制转换实现

class Automobile {}

public class Holder1 {
  private Automobile a;
  public Holder1(Automobile a) { this.a = a; }
  Automobile get() { return a; }
} ///:~

//: generics/Holder2.java

public class Holder2 {
  private Object a;
  public Holder2(Object a) { this.a = a; }
  public void set(Object a) { this.a = a; }
  public Object get() { return a; }
  public static void main(String[] args) {
    Holder2 h2 = new Holder2(new Automobile());
    Automobile a = (Automobile)h2.get();
    h2.set("Not an Automobile");
    String s = (String)h2.get();
    h2.set(1); // Autoboxes to Integer
    Integer x = (Integer)h2.get();
  }
} ///:~
此时与其使用Object,我们更喜欢暂时不指定类型,而是稍后再决定具体使用什么类型。要达到这个目的,需要使用次类型参数,用尖括号括住,放在类名后面。然后在使用这个类的时候,再用实际的类型替换此类型参数。在下面的例子中,T就是类型参数:

//: generics/Holder3.java

public class Holder3<T> {
  private T a;
  public Holder3(T a) { this.a = a; }
  public void set(T a) { this.a = a; }
  public T get() { return a; }
  public static void main(String[] args) {
    Holder3<Automobile> h3 =
      new Holder3<Automobile>(new Automobile());
    Automobile a = h3.get(); // No cast needed不需要强制转换
    // h3.set("Not an Automobile"); // Error
    // h3.set(1); // Error
  }
} ///:~
当你创建Holder3对象时,必须指明想要持有什么类型的对象,将其置于尖括号内。

泛型接口

泛型也可以应用于接口

    interface Info< T>{  // 在接口上定义泛型  
     public T getVar() ; // 定义抽象方法,抽象方法的返回值就是泛型类型  
    }  
    class InfoImpl< T> implements Info< T>{ // 定义泛型接口的子类  
     private T var ;    // 定义属性  
     public InfoImpl(T var){  // 通过构造方法设置属性内容  
      this.setVar(var) ;   
     }  
     public void setVar(T var){  
      this.var = var ;  
     }  
     public T getVar(){  
      return this.var ;  
     }  
    };  
    public class GenericsDemo24{  
     public static void main(String arsg[]){  
      Info< String> i = null;  // 声明接口对象  
      i = new InfoImpl< String>("汤姆") ; // 通过子类实例化对象  
      System.out.println("内容:" + i.getVar()) ;  
     }  
    };  

泛型方法

目前为止,我们看到的泛型都是应用于整个类上。但同样也可以在类中包含参数化方法,而这个方法所在的类是否是泛型类没有关系。

要定义泛型方法,只需将泛型参数列表置于返回值之前,修饰符之后

class Demo{  
 public <T> T fun(T t){   // 可以接收任意类型的数据  
  return t ;     // 直接把参数返回  
 }  
};  
public class GenericsDemo26{  
 public static void main(String args[]){  
  Demo d = new Demo() ; // 实例化Demo对象  
  String str = d.fun("汤姆") ; // 传递字符串  
  int i = d.fun(30) ;  // 传递数字,自动装箱  
  System.out.println(str) ; // 输出内容  
  System.out.println(i) ;  // 输出内容  
 }  
};
通过泛型方法返回泛型类型实例

class Info< T extends Number>{ // 指定上限,只能是数字类型  
 private T var ;  // 此类型由外部决定  
 public T getVar(){  
  return this.var ;   
 }  
 public void setVar(T var){  
  this.var = var ;  
 }  
 public String toString(){  // 覆写Object类中的toString()方法  
  return this.var.toString() ;   
 }  
};  
public class GenericsDemo27{  
 public static void main(String args[]){  
  Info<Integer> i = fun(30) ;  
  System.out.println(i.getVar()) ;  
 }  
 public static <T extends Number> Info< T> fun(T param){//方法中传入或返回的泛型类型由调用方法时所设置的参数类型决定  
  Info<T> temp = new Info<T>() ;  // 根据传入的数据类型实例化Info  
  temp.setVar(param) ;  // 将传递的内容设置到Info对象的var属性之中  
  return temp ; // 返回实例化对象  
 }  
};  


通配符与上下界

在使用泛型类的时候,既可以指定一个具体的类型,如List<String>就声明了具体的类型是String;也可以用通配符?来表示未知类型,如List<?>就声明了List中包含的元素类型是未知的。 通配符所代表的其实是一组类型,但具体的类型是未知的。List<?>所声明的就是所有类型都是可以的。但是List<?>并不等同于List<Object>。List<Object>实际上确定了List中包含的是Object及其子类,在使用的时候都可以通过Object来进行引用。而List<?>则其中所包含的元素类型是不确定。其中可能包含的是String,也可能是 Integer。如果它包含了String的话,往里面添加Integer类型的元素就是错误的。正因为类型未知,就不能通过new ArrayList<?>()的方法来创建一个新的ArrayList对象。因为编译器无法知道具体的类型是什么。但是对于 List<?>中的元素确总是可以用Object来引用的,因为虽然类型未知,但肯定是Object及其子类。考虑下面的代码:

public void wildcard(List<?> list) {
    list.add(1);//编译错误 
} 
如上所示,试图对一个带通配符的泛型类进行操作的时候,总是会出现编译错误。其原因在于通配符所表示的类型是未知的。

因为对于List<?>中的元素只能用Object来引用,在有些情况下不是很方便。在这些情况下,可以使用上下界来限制未知类型的范围。 如List<? extends Number>说明List中可能包含的元素类型是Number及其子类。而List<? super Number>则说明List中包含的是Number及其父类。当引入了上界之后,在使用类型的时候就可以使用上界类中定义的方法。比如访问 List<? extends Number>的时候,就可以使用Number类的intValue等方法。

通配符安全使用的demo

    class Info< T>{  
     private T var ;  // 定义泛型变量  
     public void setVar(T var){  
      this.var = var ;  
     }  
     public T getVar(){  
      return this.var ;  
     }  
     public String toString(){ // 直接打印  
      return this.var.toString() ;  
     }  
    };  
    public class GenericsDemo14{  
     public static void main(String args[]){  
      Info< String> i = new Info< String>() ;  // 使用String为泛型类型  
      i.setVar("it") ;       // 设置内容  
      fun(i) ;  
     }  
     public static void fun(Info< ?> temp){  // 可以接收任意的泛型对象  
      System.out.println("内容:" + temp) ;  
     }  
    };  
      
受限类型

class Info< T>{  
 private T var ;  // 定义泛型变量  
 public void setVar(T var){  
  this.var = var ;  
 }  
 public T getVar(){  
  return this.var ;  
 }  
 public String toString(){ // 直接打印  
  return this.var.toString() ;  
 }  
};  
public class GenericsDemo17{  
 public static void main(String args[]){  
  Info< Integer> i1 = new Info< Integer>() ;  // 声明Integer的泛型对象  
  Info< Float> i2 = new Info< Float>() ;   // 声明Float的泛型对象  
  i1.setVar(30) ;         // 设置整数,自动装箱  
  i2.setVar(30.1f) ;        // 设置小数,自动装箱  
  fun(i1) ;  
  fun(i2) ;  
 }  
 public static void fun(Info< ? extends Number> temp){ // 只能接收Number及其Number的子类  
  System.out.print(temp + "、") ;  
 }  
}; 

class Info< T>{  
 private T var ;  // 定义泛型变量  
 public void setVar(T var){  
  this.var = var ;  
 }  
 public T getVar(){  
  return this.var ;  
 }  
 public String toString(){ // 直接打印  
  return this.var.toString() ;  
 }  
};  
public class GenericsDemo21{  
 public static void main(String args[]){  
  Info< String> i1 = new Info< String>() ;  // 声明String的泛型对象  
  Info< Object> i2 = new Info< Object>() ;  // 声明Object的泛型对象  
  i1.setVar("hello") ;  
  i2.setVar(new Object()) ;  
  fun(i1) ;  
  fun(i2) ;  
 }  
 public static void fun(Info< ? super String> temp){ // 只能接收String或Object类型的泛型  
  System.out.print(temp + "、") ;  
 }  
};

类型擦除

开发人员在使用泛型的时候,很容易根据自己的直觉而犯一些错误。比如一个方法如果接收List<Object>作为形式参数,那么如果尝试将一个List<String>的对象作为实际参数传进去,却发现无法通过编译。虽然从直觉上来说,Object是String的父类,这种类型转换应该是合理的。但是实际上这会产生隐含的类型转换问题,因此编译器直接就禁止这样的行为。

正确理解泛型概念的首要前提是理解类型擦除(type erasure)。 Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节代码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数,会被编译器在编译的时候去掉。这个过程就称为类型擦除。如在代码中定义的List<Object>和List<String>等类型,在编译之后都会变成List。JVM看到的只是List,而由泛型附加的类型信息对JVM来说是不可见的。Java编译器会在编译时尽可能的发现可能出错的地方,但是仍然无法避免在运行时刻出现类型转换异常的情况。类型擦除也是Java的泛型实现方式与C++模板机制实现方式之间的重要区别。

很多泛型的奇怪特性都与这个类型擦除的存在有关,包括:

  • 泛型类并没有自己独有的Class类对象。比如并不存在List<String>.class或是List<Integer>.class,而只有List.class。
  • 静态变量是被泛型类的所有实例所共享的。对于声明为MyClass<T>的类,访问其中的静态变量的方法仍然是 MyClass.myStaticVar。不管是通过new MyClass<String>还是new MyClass<Integer>创建的对象,都是共享一个静态变量。
  • 泛型的类型参数不能用在Java异常处理的catch语句中。因为异常处理是由JVM在运行时刻来进行的。由于类型信息被擦除,JVM是无法区分两个异常类型MyException<String>和MyException<Integer>的。对于JVM来说,它们都是 MyException类型的。也就无法执行与异常对应的catch语句。
类型擦除的基本过程也比较简单,首先是找到用来替换类型参数的具体类。这个具体类一般是Object。如果指定了类型参数的上界的话,则使用这个上界。把代码中的类型参数都替换成具体的类。同时去掉出现的类型声明,即去掉<>的内容。比如T get()方法声明就变成了Object get();List<String>就变成了List。接下来就可能需要生成一些桥接方法(bridge method)。这是由于擦除了类型之后的类可能缺少某些必须的方法。比如考虑下面的代码:

class MyString implements Comparable<String> {
    public int compareTo(String str) {        
        return 0;    
    }
} 

当类型信息被擦除之后,上述类的声明变成了class MyString implements Comparable。但是这样的话,类MyString就会有编译错误,因为没有实现接口Comparable声明的int compareTo(Object)方法。这个时候就由编译器来动态生成这个方法。

案例分析

了解了类型擦除机制之后,就会明白编译器承担了全部的类型检查工作。编译器禁止某些泛型的使用方式,正是为了确保类型的安全性。以上面提到的List<Object>和List<String>为例来具体分析:

public void inspect(List<Object> list) {    
    for (Object obj : list) {        
        System.out.println(obj);    
    }    
    list.add(1); //这个操作在当前方法的上下文是合法的。 
}
public void test() {    
    List<String> strs = new ArrayList<String>();    
    inspect(strs); //编译错误 
} 

这段代码中,inspect方法接受List<Object>作为参数,当在test方法中试图传入List<String>的时候,会出现编译错误。假设这样的做法是允许的,那么在inspect方法就可以通过list.add(1)来向集合中添加一个数字。这样在test方法看来,其声明为List<String>的集合中却被添加了一个Integer类型的对象。这显然是违反类型安全的原则的,在某个时候肯定会抛出ClassCastException。因此,编译器禁止这样的行为。编译器会尽可能的检查可能存在的类型安全问题。对于确定是违反相关原则的地方,会给出编译错误。当编译器无法判断类型的使用是否正确的时候,会给出警告信息。

类型擦除引起的问题
  1. 类型匹配
            在使用泛型化的集合类的时候,往往会遇到类型不匹配的问题。这个问题是由于变量声明的过程中等号左右两侧的泛型类型不一致所导致的。一个统一的写法类似如下代码:
    List<String> list = new ArrayList<String>();  
       2.类型判定
    if (list instanceof ArrayList<String>) {// do something...}  

       3.不能使用基本类型

    List<double> list = new ArrayList<double>();  
Java的泛型化参数是通过类的继承关系来确定一个类对象的。这注定了泛型化参数是不能使用基本类型的,只能使用包装类型。

       4.不能将类声明中的泛型化参数静态化

        形如下列代码的泛型声明是非法的,因为静态化的过程和泛型化过程是矛盾的:

    package com.homeland.myapp;  
      
    import java.util.ArrayList;  
    import java.util.List;  
      
    public class GenericDemo<T> {  
          
        private static T one;  
      
        public static void main(String[] args) {  
            // do something...  
        }  
      
    }  
但是,静态化的泛型方法是可行的:
    package com.homeland.myapp;  
      
      
    public class GenericDemo<T> {  
          
        public static void main(String[] args) throws Exception {  
            // do something...  
        }  
          
        private static <T> T doSomething(T arg) {  
            return null;  
        }  
      
    }  

这些问题可以大致上这么理解:当你使用泛型的时候,泛型化的参数类型要保持一致或者兼容,当类型未确定的时候,一切执行类型判定,类型静态化,用基本类型代替包装类的做法都是非法的。类型的擦除所导致的问题的根本就是: 你不能把一个擦除了类型信息的对象当做具体的类型来判定,任何实例化的,静态化的行为都是非法的。类型擦除的问题相对泛型协变问题没有协变那么隐晦,难懂。一般来说,擦除所导致的问题都可以在书写过程中所避免。

类型系统

在Java中,大家比较熟悉的是通过继承机制而产生的类型体系结构。比如String继承自Object。根据Liskov替换原则,子类是可以替换父类的。当需要Object类的引用的时候,如果传入一个String对象是没有任何问题的。但是反过来的话,即用父类的引用替换子类引用的时候,就需要进行强制类型转换。编译器并不能保证运行时刻这种转换一定是合法的。这种自动的子类替换父类的类型转换机制,对于数组也是适用的。 String[]可以替换Object[]。但是泛型的引入,对于这个类型系统产生了一定的影响。正如前面提到的List<String>是不能替换掉List<Object>的。

引入泛型之后的类型系统增加了两个维度:一个是类型参数自身的继承体系结构,另外一个是泛型类或接口自身的继承体系结构。第一个指的是对于 List<String>和List<Object>这样的情况,类型参数String是继承自Object的。而第二种指的是 List接口继承自Collection接口。对于这个类型系统,有如下的一些规则:

  • 相同类型参数的泛型类的关系取决于泛型类自身的继承体系结构。即List<String>是Collection<String> 的子类型,List<String>可以替换Collection<String>。这种情况也适用于带有上下界的类型声明。
  • 当泛型类的类型声明中使用了通配符的时候, 其子类型可以在两个维度上分别展开。如对Collection<? extends Number>来说,其子类型可以在Collection这个维度上展开,即List<? extends Number>和Set<? extends Number>等;也可以在Number这个层次上展开,即Collection<Double>和 Collection<Integer>等。如此循环下去,ArrayList<Long>和 HashSet<Double>等也都算是Collection<? extends Number>的子类型。
  • 如果泛型类中包含多个类型参数,则对于每个类型参数分别应用上面的规则。

理解了上面的规则之后,就可以很容易的修正实例分析中给出的代码了。只需要把List<Object>改成List<?>即可。List<String>是List<?>的子类型,因此传递参数时不会发生错误。

最佳实践

在使用泛型的时候可以遵循一些基本的原则,从而避免一些常见的问题。

  • 在代码中避免泛型类和原始类型的混用。比如List<String>和List不应该共同使用。这样会产生一些编译器警告和潜在的运行时异常。当需要利用JDK 5之前开发的遗留代码,而不得不这么做时,也尽可能的隔离相关的代码。
  • 在使用带通配符的泛型类的时候,需要明确通配符所代表的一组类型的概念。由于具体的类型是未知的,很多操作是不允许的。
  • 泛型类最好不要同数组一块使用。你只能创建new List<?>[10]这样的数组,无法创建new List<String>[10]这样的。这限制了数组的使用能力,而且会带来很多费解的问题。因此,当需要类似数组的功能时候,使用集合类即可。
  • 不要忽视编译器给出的警告信息。

参考资料:http://www.infoq.com/cn/articles/cf-java-generics/


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值