java泛型

泛型是JAVA SE5之后才出现的概念，“泛型”其实就是指类型的参数化。我们知道Java是单继承体系的，这就使得我们在编写程序时，很容易受到限制，不能实现代码的复用。泛型一个重要的应用就是实现了“容器类”，如果不使用泛型，我们只能编写下面的程序：
 
Java代码  
public class Holder {  
      private Object a;  
      public Holder(Object a) { this.a = a; }  
      public void set(Object a) { this.a = a; }  
      public Object get() { return a; }  
      public static void main(String[] args) {  
        Holder h2 = new Holder("The String");  
        String s = (String)h2.get();  
        h2.set(1);  
        Integer x = (Integer)h2.get();  
      }  
    }   
 虽然我们可以实现了可以同时持有不同的类型，但是我们取出时必须进行强制类型转化，如果不小心还容易产生CLASSCASTEXCEPTION，如果我们使用泛型的话，可以采用下面的实现方式。由上海java培训机构推荐阅读
 
Java代码  
class Automobile{}  
  
public class GenericHolder<T> {  
      private T a;  
      public GenericHolder(T a) { this.a = a; }  
      public void set(T a) { this.a = a; }  
      public T get() { return a; }  
      public static void main(String[] args) {  
          GenericHolder<Automobile> h3 =  
          new GenericHolder<Automobile>(new Automobile());  
          Automobile a = h3.get(); // No cast needed  
//        h3.set("The String"); // Error  
//        h3.set(1); // Error  
      }  
}  
 我们通过将想要持有的对象预先放在尖括号内，编译器就会对放置的类型进行检测，防止出错。泛型应用于接口与泛型类差不多，这里就不在解释了。
        泛型也可以应用于方法，泛型方法使得方法能够独立于类产生变化。泛型方法与其所处的类是否为泛型是没有任何关系的。
 
Java代码  
public class GenericMethods {  
    public <T> void f(T x) {  
        System.out.println(x.getClass().getName());  
    }  
  
    public static void main(String[] args) {  
        GenericMethods gm = new GenericMethods();  
        gm.f("");  
        gm.f(1);  
        gm.f(1.0);  
        gm.f(1.0F);  
        gm.f('c');  
        gm.f(gm);  
    }  
}  
       对比以上的泛型方法与泛型类，可以看出：当使用泛型类是，必须在创建对象的时候指定类型参数的值，而使用泛型方法时，通常不用指明参数的类型；编译器可以通过类型推断为我们找出具体的类型（只在赋值操作时起作用）。其他的时候也需要显示的指明类型，此时可以在点操作符与方法名之间插入尖括号例如：
Java代码  
gm.<GenericMethods>f(gm);  
 可以看出泛型方法较泛型类更加的简洁和容易理解，所以我们在编程时应当尽量的使用泛型方法。
          以上为泛型的基础应用，在学习泛型时，看到下面一处奇怪的代码：
 
Java代码  
public class ErasedTypeEquivalence {  
     @SuppressWarnings("rawtypes")  
    public static void main(String[] args) {  
            Class c1 = new ArrayList<String>().getClass();  
            Class c2 = new ArrayList<Integer>().getClass();  
            System.out.println(c1 == c2);  
          }  
}  
         对于ArrayList<String>和ArrayList<Integer>我们很容易认为它们是不同的类型，的确它们是不同的类型然而程序的输出却是"TRUE"；这是由于Java的泛型是使用擦出来实现的，当我们使用泛型时，任何具体的类型信息都被擦除了，List<String>和List<Integer>在运行时都被擦出为成原生类型List了。
        然而Java为什么要这么做呢？我们前面提到泛型在JAVA SE5之后才出现的，Java泛型使用擦除的原因在于向前兼容。即即使类库进行了代码改造使用了新的泛型实现，客户端依然可以在不改变代码的前提下继续使用这个类库，使得在不破坏现有类库的前提下，将泛型融入到了java语言中。更多Java相关请移步http://www.shaccp.cn/
       然而通过擦除实现了Java中的泛型，必然会付出一定的代价，使得Java中的泛型不能用于显示地引用运行时类型的操作之中，例如：转型、instanceof操作和new表达式，而这些在C++中是可以使用的，在java中我们可以通过反射来间接的实现。由于擦出的存在下面这种方式试图重载方法是不正确的：
 
Java代码  
public class UseList<W, T> {  
//错误：Method f(List<T>) has the same erasure f(List<E>) as another method in type UseList<W,T>  
    void f(List<T> v){}  
    void f(List<W> v){}  
}  
 
所以我们应当注意的是java中的泛型只有在静态类型检查期间才会出现，在此之后，程序中所有的泛型类型都将被擦出，替换为它的非泛型边界。
      什么边界？
 边界使得我们可以在用于泛型的参数类型上设置限制条件：一方面使得我们可以规定泛型参数可以使用的类型，另一方面使得我们可以按照自己的边界类型来调用方法。例如：
 
Java代码  
class HasF {  
    public void f() {  
        System.out.println("HasF.f()");  
    }  
}  
  
class Manipulator<T> {  
    private T obj;  
  
    public Manipulator(T x) {  
        obj = x;  
    }  
  
    // Error: 未发现方法f()  
    public void manipulate() {  
        obj.f();  
    }  
}  
  
public class Manipulation {  
    public static void main(String[] args) {  
        HasF hf = new HasF();  
        Manipulator<HasF> manipulator = new Manipulator<HasF>(hf);  
        manipulator.manipulate();  
    }  
}   
 由于使用了擦除，Java编译器不能obj可以调用方法f()映射到HasF拥有方法f()这个情况上，此时我们可以使用边界，例如：
 
 
Java代码  
class Manipulator2<T extends HasF> {  
    private T obj;  
    public Manipulator2(T x) {  
        obj = x;  
    }  
    public void manipulate() {  
        obj.f();  
    }  
}  
 此时obj可以直接调用方法f()了。然后我们可以看出此时这样的泛型并没有给我们任何好处，我们不使用泛型，只需将Manipulator<T>中的T替换为HasF并且使用原生类Manipulator也可以实现以上的功能。所以使用泛型时我们最好自己的思考一下，我们的问题是否足够的复杂到必须使用泛型的程度，也就是说我们编写的这部分代码能够跨多个类进行工作。
 
       我们看到
Java代码  
class Manipulator2<T extends HasF>  
这里的extends与我们在普通情况下看到的是不同的，因为java泛型重用了extends关键字。
 
     我们继续分析下面一个比较难以理解的例子：
 
Java代码  
class Fruit {}  
class Apple extends Fruit {}  
class Jonathan extends Apple {}  
class Orange extends Fruit {}  
  
public class GenericsAndCovariance {  
     public static void main(String[] args) {  
            //编译错误：Type mismatch: cannot convert from ArrayList<Apple> to List<Fruit>  
            //List<Fruit> flist = new ArrayList<Apple>();  
            List<? extends Fruit> flist = new ArrayList<Apple>();  
            // 编译错误：不能添加任何类型  
            //flist.add(new Apple());  
            // flist.add(new Fruit());  
            // flist.add(new Object());  
            flist.add(null); // Legal but uninteresting  
            Fruit f = flist.get(0);  
              
            List<Fruit> flist2 = new ArrayList<>();  
            flist2.add(new Apple());  
          }  
}  
 
 
 如下：List<Fruit>表示持有Fruit以及Fruit的子类型，我们可以向flist2中添加Fruit的子类型Apple，然而Apple的List在类型上并不等价于Fruit的List
Java代码  
List<Fruit> flist = new ArrayList<Apple>();  
再看flist类型为List<? extends Fruit>我们可以理解为“具有任何从Fruit继承的某种类型的列表” 通配符表示flist指向某种没有指定的具体类型，听着有些拗口，这里?指某种而不是某些。如果允许以下操作：
Java代码  
flist.add(new Apple());  
flist.add(new Fruit());  
flist.add(new Object());  
 我们在取出时由于不知道flist中的具体类型，又必须进行强制类型转换，这与泛型的思想又是背道而驰的。
所以我们在使用<? extends SomeClass>时，意味着我们只能通过这个名称来获取或者移除某些信息，而不能增加它的信息。
       如果想要写入或者增加信息我们可以使用超类行通配符<? super SomeClass>，例如：
Java代码  
public class SuperTypeWildcards {  
    static void writeTo(List<? super Apple> apples) {  
        apples.add(new Apple());  
        apples.add(new Jonathan());  
        // apples.add(new Fruit()); // Error  
      }  
}  
 泛型中还存在另一种无界通配符<?>，意味着任何事物”
Java代码  
public class UnboundedWildcards1 {  
      @SuppressWarnings("rawtypes")  
    static List list1;  
      static List<?> list2;  
      static List<? extends Object> list3;  
    static void assign1(@SuppressWarnings("rawtypes") List list) {  
        list1 = list;  
        list2 = list;  
        list3 = list; // Warning: unchecked conversion  
        // Found: List, Required: List<? extends Object>  
      }  
      static void assign2(List<?> list) {  
        list1 = list;  
        list2 = list;  
        list3 = list;  
      }   
      static void assign3(List<? extends Object> list) {  
        list1 = list;  
        list2 = list;  
        list3 = list;  
      }  
      @SuppressWarnings("rawtypes")  
    public static void main(String[] args) {  
        list1.add(new Integer(1));  
          
//      错误list2与list3中只能添加null  
//      list2.add(new Integer(1));  
//      list3.add(new Integer(1));  
          
        assign1(new ArrayList());  
        assign2(new ArrayList());  
        assign3(new ArrayList()); // Warning:  
        // Unchecked conversion. Found: ArrayList  
        // Required: List<? extends Object>  
        assign1(new ArrayList<String>());  
        assign2(new ArrayList<String>());  
        assign3(new ArrayList<String>());  
        // Both forms are acceptable as List<?>:  
        List<?> wildList = new ArrayList();  
        wildList = new ArrayList<String>();  
        assign1(wildList);  
        assign2(wildList);  
        assign3(wildList);  
      }  
    }  
 List表示“持有任何Object类型的原生List”，List<?>表示“具有某种特定类型的非原生List”。
List<?>和List<? extends Object>大致是等价的。
    所以我们应当理解泛型的含义就是：泛化的类型，适用于很多的类型。通过泛型我们可以编写出更“泛化”的代码，这些代码对于它能作用的类型具有更少的限制，使得单个的代码段可以应用到更多的类型上。