泛型的注意事项

1、不可以用一个本地类型（如int   float）来替换泛型.比如List<Integer>不能用List<int>型式

2、运行时类型检查，不同类型的泛型类是等价的（Pair<String>与Pair<Employee>是属于同一个类型 Pair），这一点要特别注意:即如果a instanceof Pair<String>==true的话，并不代表a.getFirst()的返回值是一个String类型

3、泛型类不可以继承Exception类，即泛型类不可以作为异常被抛出

4、不可以定义泛型数组

5、不可以用泛型构造对象，即T first = new T(); 是错误的

6、在static方法中不可以使用泛型，泛型变量也不可以用static关键字来修饰

7、不要在泛型类中定义equals(T x)这类方法，因为Object类中也有equals方法，当泛型类被擦除后，这两个方法会冲突

8、根据同一个泛型类衍生出来的多个类之间没有任何关系，不可以互相赋值，即Pair<Number> p1; Pair<Integer> p2;   p1=p2; 这种赋值是错误的。

9、若某个泛型类还有同名的非泛型类，不要混合使用，坚持使用泛型类
     Pair<Manager> managerBuddies = new Pair<Manager>(ceo, cfo);
     Pair rawBuddies = managerBuddies; 这里编译器不会报错，但存在着严重的运行时错误隐患

 

泛型与类型转换
Java 5.0引入泛型以后,提高了类型安全性，然而也给编程带来了新的挑战以及新的误区，类型转换就是一个很好的例子。引入泛型以后，对象的类型似乎由两个类型构成：集合类型和参数类型，例如List<Integer> list = new LinkedList<Integer>()，似乎list的类型由List和Integer共同决定。如果真是这样，那么我们如果希望对list进行类型转换，我们该怎么办？是对List转换，还是对Integer转换？要解答上面的问题很简单，编写如下的代码，运行之就可看出端倪：

  public   static   void  wrongConversion()   {
        List < Integer >  list  =   new  LinkedList < Integer > ();
        list.add( 1 );
        list.add( 2 );
        list.add( 3 );
       
         // 下面的代码无法编译通过。
         // List<Number> wrongList = list;
        
    }
   
     public   static   void  rightConversion()   {
        LinkedList < Integer >  list  =   new  LinkedList < Integer > ();
        list.add( 10 );
        list.add( 20 );
        list.add( 30 );
       
        List < Integer >  rightList  =  list;
         for ( int  number: rightList)   {
            System.out.println(number);
        }
       
    }
如果你运行上面的代码，你会发现前一个函数根本无法通过编译，而后一个函数不仅编译成功，而且能得到正确结果。这似乎给出了一个结论：对象的类型由集合类型来决定，对对象进行类型转换时也是对集合类型进行转换。事实确实如此！那么为什么会如此呢？
我们可以回忆一下以前我们对参数类型的描述：参数类型不过是一个占位符而已，在编译时，它会被具体的类型代替，同时对添加到集合对象中的数据进行参数检查；如果添加到对象中的数据类型不是指定的具体类型或其子类型，则编译出错；而且，编译以后，该占位符会被移除，运行时你是无法得到任何集合类型中数据的类型信息的。简而言之：
         List<String> strings = new LinkedList<String>( );
         List<Integer> ints = new LinkedList<Integer>( );
上面的代码在运行时和
         List strings = new LinkedList( );
         List ints = new LinkedList( );
毫无二致。了解了这一点以后，相信我们对于类型转换也会有更深的理解了。
泛型给我们带来了好处，使我们在编译时就能发现很多错误；然而任何事物都是柄双刃剑，泛型也不例外。泛型的缺点最明显之处就在于类型转换。如果你读过前面的文章，肯定看到过不带参数类型的集合对象转换为带参数类型的集合对象，其实不仅仅如此，这两者之间可以任意转换。这就意味着一点，我们不仅可以对集合类型进行转换，也可以对参数类型进行任意的转换。这似乎与前面的描述不符，因为上面的代码中的List<Number> wrongList = list;根本无法编译通过。确实如此，这行代码确实无法编译通过，不过我们中间做一步处理以后，上面的转换就可以正常编译了：
        List mediaList = list;
        List<Number> wrongList = mediaList;
由此可见，泛型在给我们带来好处的同时，也带来了无数陷阱，我们在编程时需十分注意，而Java的泛型机制也需要不断更新。
最后和以往一样，以一个拙劣的程序结束本文：
 package  com.jiang.tiger.chap1;

 import  java.util.ArrayList;
 import  java.util.LinkedList;
 import  java.util.List;

 public   class  GenericReflection   {
     private   static  List < Integer >  ints  =   new  ArrayList < Integer > ( );
   
     public   static   void  fillList(List < Integer >  list)   {
         for  (Integer i : list)   {
          ints.add(i);
        }
    }
   
     public   static   void  printList( )   {
         for  (Integer i : ints)   {
            System.out.println(i);
        }
    }
   
     public   static   void  badConversion()   {
        List < Integer >  list  =   new  LinkedList < Integer > ();
        list.add( 1 );
        list.add( 2 );
        list.add( 3 );
        fillList(list);
        printList();
        List badList  =  list;
        badList.add( " bad number " );
        badList.add( " wrong idea " );
        fillList(list);
        printList();
       
    }
   
     public   static   void  badConversion2()   {
        List list  =   new  LinkedList();
        list.add( 1 );
        list.add( 2 );
        list.add( " bad number " );
       
        List < Integer >  badList  =  list;
        badList.add( 12 );
         for  (Integer i : badList)   {
            System.out.println(i);
        }
    }
   
     public   static   void  wrongConversion()   {
        List < Integer >  list  =   new  LinkedList < Integer > ();
        list.add( 100 );
        list.add( 200 );
        list.add( 300 );
       
         // 下面的代码无法编译通过。
         // List<Number> wrongList = list;
         List mediaList  =  list;
        List < Number >  wrongList  =  mediaList;
        wrongList.add( 120.23 );
        wrongList.add( 0.1230 );
         for (Integer inter : list)   {
            System.out.println(inter);
        }
       
    }
   
     public   static   void  rightConversion()   {
        LinkedList < Integer >  list  =   new  LinkedList < Integer > ();
        list.add( 10 );
        list.add( 20 );
        list.add( 30 );
       
        List < Integer >  rightList  =  list;
         for (Integer number: rightList)   {
            System.out.println(number);
        }
       
    }
   
     public   static   void  badReflection()   {
        List < Integer >  myInts  =   new  ArrayList < Integer > ( );
       
        myInts.add( 4 );
        myInts.add( 5 );
        myInts.add( 6 );   
       
        System.out.println( " Filling list and printing in normal way " );
        fillList(myInts);
        printList( );
       
         try    {
            List list  =  (List)GenericReflection. class .getDeclaredField( " ints " ).get( null );
            list.add( " Illegal Value! " );
        }   catch  (Exception e)   {
            e.printStackTrace( );
        }
        System.out.println( " Printing with illegal values in list " );
        printList( );
    }
   
     public   static   void  main(String[] args)   {
       
        System.out.println( " rightConversion " );
        rightConversion();
         try  {
            Thread.sleep( 1000 );
            System.out.println( " badConversion " );
            badConversion();
        }   catch (Exception ce)   {
            ce.printStackTrace();
        }
          try  {
            Thread.sleep( 1000 );
            System.out.println( " badConversion2 " );
            badConversion2();
        }   catch (Exception ce)   {
            ce.printStackTrace();
        }
          try  {
            Thread.sleep( 1000 );
            System.out.println( " wrongConversion " );
            wrongConversion();
        }   catch (Exception ce)   {
            ce.printStackTrace();
        }
          try  {
            Thread.sleep( 1000 );
            System.out.println( " badReflection " );
            badReflection();
        }   catch (Exception ce)   {
            ce.printStackTrace();
        }
       
    }
}