Java泛型

Java泛型 总结 Java泛型是 jdk5.0 以后的版本才有的特性，也是 Sun 公司将 JDK1.5. 更名为 JDK5.0 的一个重要原因，因为历时 5 年的开发，是 JDK1.5 的功能更为健全和完善。 
重用度高，安全系数高是Java 的追求的目标，而泛型的运用正是这一个内容的重要体现。在学习 Java 的过程当中 Java 泛型感觉有些晦涩难懂。起先以为自己的泛型学的还不错，可是在很长一段时间研究 Java 泛型毫无进展的情况下，开始有些崩溃了，于是硬着头皮看啊看，终于觉得有点感觉了，所以，今天在这里总结一些 Java 泛型的一些知识，希望以后自己以后开发生涯中能够用上今天的经验，写下来的原因确实很多，我不想在遇到同样的问题而束手无策，而且记忆了有时候并不是十分的可靠，所以我准备了 4 天的时间来写这篇总结。希望能详尽的表述出来，这个非常适用的机制，并方便以后读到这篇文章的读者，能够提出你们对泛型的一些看法，而不仅仅是一个“顶”字，我也相信你们有比这更好的学习泛型的经验和教训。 

什么是泛型？ 泛型实质上是叫做泛型程序设计。运用泛型意味着编写的代码可以被很多类型不同的对象所 重用 。 
为什么使用泛型？泛型是一种全新的程序设计手段，使用泛型的机制编写的程序代码，要比那些杂乱的使用Object 变量然后进行强制类型转化的代码明显的具有以下特点： 1 更好的安全性 2  更好的可读性。 

了解这个两个问题才能从根本上了解泛型的好处，也才能真正的了解甚至熟练的运用Java 泛型。 
先前受到c++ 模板的影响，所以一时还难以转过弯来。后来发现 C++ 的模板比 Java 的泛型做得好一些。一般情况下， Java 的特点是“懒加载”（源自 Hibernate 中的 lazy 这里只是为了说明），即运行时才动态的调用方法和生成新的类（除了 static 块和域）。所以 Java 并不知道你所指的泛型到底是什么类型。 Java 是一门纯面向对象的语言，所有的东西必须用类来表示（除了基本的数据类型外），所以类型可以泛化但是不能不让编译器始终不知道你所要泛化的东西是何种类型。因此有一定 C++ 基础的人千万要将模板和 Java 的泛型区分开来。 
泛型最初的目的是希望类或者方法能够具备更加广泛的表达能力。了解泛型最主要的是要了解泛型的边界，以及它可以用来做什么，不能够做什么。我想这点是最重要的。 
在此之前，我们用的最多的就是多态。所以经常性的让类来持有Object 类型的对象。 
package  cn.ccsu.cooole.generics; 
/** 
  *   @author   CoolPrince 
  *    这里讲的是一个类持有某一个类的对象本案例中用的是代理的机制 
  *    即Holder_1类持有AObject的对象ao; 
  *    这个通常情况下只能持有单个对象的类 
  */ 
public   class  Holder_1 { 
     private  AObject  ao  =  null ; 
public  Holder_1(AObject ao) { 
this . ao  = ao; 
} 
AObject  get(){ return   ao ; } 
} 
class  AObject{} 
在举个例子（解释详见注释部分）： 
package  cn.ccsu.cooole.generics; 
/** 
  *   
  *   @author   CoolPrince 
  *   描述：此案例讲的是以前我们所用到过的动态绑定，此时只用了一个Holder_2的对象 
  * 就实现了存储两个不同的类型的对象的功能。 
  *   有些情况下我们主要运用泛型是将其运用到容器当中，告诉指定容器要持有什么样类型     * 的对象   由编译器来保证类型的正确性，举个简单的例子   List <Integer>   list   =   
* new   ArrayList <Integer> ();   此时前后的类型都为Integer才能保证数据的正确性. 
  */ 
public   class  Holder_2 { 
     private  Object  a   =  null ; 
public  Holder_2(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 h =  new  Holder(); 
Holder_2 h2 =  new  Holder_2(h); 
print ( "Test Holder result is ：" + h2.get()); 
String str =  new   String( "Name is /" String/"" ); 
h2.set(str); 
print ( "Test String result is ：" + h2.get()); 

} 
private   static   void  print(Object o){ 
System. out .println(o); 
} 
} 
class  Holder{ 
public  String toString(){ return   "Name is /"Holder/"" ;} 
} 
以上便是使用Object 数据类型的来进行动态绑定，但是与其指定为 Object 还不如暂时不指定类型，然后决定具体使用何种类型。 
下面就真正开始归纳泛型的基本用法和简要的总结： 

package  cn.ccsu.cooole.generics; 
/** 
  *   
  *   @author   CoolPrince 
  *   @param   <T> 
  *   泛型示例 主要是看简单泛型的基本语法格式 
  */ 
public   class  Holder_3<T> { 

public  Holder_3(T a){ this . a  = a;} 
public  T get(){ return   a ;} 
public   void  set(T a){ this . a  = a;} 


public   static   void  main(String[] args) { 
Holder h =  new  Holder(); 
Holder_3<Holder>   h3  =  new  Holder_3<Holder>(h);  
System. out .println( h3 ); 
Holder hh =  h3 .get(); 
System. out .println(hh); 
/* h3 .set("cooole"); //h3已经限定了其类型为Holder所以其他类型 
h3 .set(new Integer(1));//比如String、Integer还是其他非Holder类   型 
都是不允许传进来类型参数的 
      */ 
} 
private  T  a ; 
} 
    Java泛型的核心概念：告诉编译器像使用什么类型，然后编译器帮你处理一切细节。在使用泛型时只需要指定它们的名称和类型即可。 

在通常的系统开发当中，我们一定会遇到经常使用一次方法调用，就能返回多个对象的情况。但是return 只能返回一个对象。因此解决办法就就是：创建一个对象用这个对象来持有想要返回的多个对象。当然在每次需要的时候就会专门创建这样的类。万一系统庞大，那么就会出现各种各样的问题，类就会过于庞大，同时也不能很好的体现 OOP 的思想。有一种好的设计思想就是利用泛型来一次性来解决问题，同时也可以利用泛型来在编译期间进行检查确保类型的安全，同时泛型也不是十全十美的会有一定的性能下降。 
在学习泛型的时候要注意到元组的问题，实质上在通常的情况下可以这样来理解，元组就是类型的列表外加<> 。 

泛型也可以运用到接口上这样的接口称为泛型接口。 
public   interface   GenericsInterface <T> {T method();} 是被允许的。 
Java泛型“基本类型无法作为类型参数”的局限性已经是众所周知了，不过从 J2SE5 
就具备了自动打包和解包的功能，所以基本的数据类型会也应该转换为对应的对象类型，再进行下一步的处理。 
     
   泛型到现在的示例为止都是运用于整个类。但是从实际开发的过程中的规范或者说是好的习惯来看， 在能力的范围内，能用泛型方法代替泛型类的就应该尽量代替 。所以在这里就要讲到泛型方法的基本语法结构和一些必须非常熟悉的基本原理，这样才能站在更高的层次上来理解Java 泛型。 
    先介绍语法： 
package  cn.ccsu.cooole.generics; 

/** 
  *   @author   CoolPrince 
  *   本案例的输出情况： 
  *   SampleName:    String    |    Name:    java.lang.String 
  *   SampleName:    Float    |    Name:    java.lang.Float 
  *   SampleName:    Integer    |    Name:    java.lang.Integer 
  *   SampleName:    Integer    |    Name:    java.lang.Integer 
  *   从输出情况可以了解到两个重要的点： 
  *   1:从i0和i1这两个地方我们就能很清晰地看到： Java泛型“基本类 
  *      型无法作为类型参数”的局限性已经是众所周知了，不过从J2SE5就具 
  *      备了自动打包和解包的功能，所以基本的数据类型会也应该转换为对应 
  *      的对象类型，再进行下一步的处理。 
  *    2:定义泛型方法只需要将泛型   参数列表   至于返回值之前 
  */ 
public   class  GenericsMethods { 
// 简单的示例输出对应的类名 
public  <T>  void  method(T x) { 
System. out .println( "SampleName:  "  +  x.getClass().getSimpleName() 
+  "  |  Name:  "  + x.getClass().getName()); 
} 

public   static   void  main(String[] args) { 
GenericsMethods gm =  new  GenericsMethods(); 
String s =  "cooole" ; 
int  i0 = 23; 
Integer i1 = 13; 
gm.method(s); 
gm.method(10.F); 
gm.method(i0); 
gm.method(i1); 
} 

} 
     值得特别注意的是： 如果static 方法需要使用泛型能力，就必须使其成为泛型方法。 
当使用泛型类时，必须在创建对象的时候指定参数的值，而使用泛型方法时，通常不必指明参数的类型，因为编译器有个功能叫做：类型参数推断，此时编译器会为我们找出具体的类型。 
     类型参数推断举例： 
package  cn.ccsu.cooole.generics; 

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

/** 
  *   @since   2009 - 7 
  *   @author   CoolPrince 
  *   @describe : 
  *   该示例展示的是类型参数推断的一个简单的示例 
  *   以及泛化方法的基本形式 
  *   泛型方法使得该方法能够独立于类而产生变化，先辈给的一个经验就是： 
  *   无论何时何地，只要你能做到的，就应该使用泛型的方法。也就是说能够将 
  *   用泛型方法取代整个类的就应该使用泛型方法。这样做会使得事情更加清晰明了。 
  *   另外值得注意的是：对于一个static的方法而言，无法访问泛型类的类型参数， 
  *   所以如果static方法需要使用的能力，就必须使其成为泛型方法。 
  *   就类型参数推断而言，那这个例子来讲，假设用户不知道GuessParaType中的方法 
  *   或者说是隐含的功能，花的时间也没有减少。工作效率也没有得到提升 
  *   
  *   需要特别特别注意的是：   类型推断只对赋值操作有效，其他时候并不起作用 
  *   （比如作为参数传递给方法）。   所以function(GuessParaType.list()) 
  *   的用法编译时候无法获得通过。   
  *   如果是定义在该方法类的内部就需要使用this而静态方法则需要添加类名。 
  */ 
public   class  GuessParaType { 
public   static  <K,V> Map<K,V>  map(){ 
return   new  HashMap<K,V>(); 
} 
public   static  <T> List<T> list(){ 
return   new  ArrayList<T>(); 
} 
public   static  <T> LinkedList<T> linkedList(){ 
return   new  LinkedList<T>(); 
} 
public   static   void  function(List<?  extends  Holder> s){ 
System. out .println(s.getClass()); 
} 
public   static   void  main(String[] args) { 
@SuppressWarnings ( "unused" ) 
Map<String,List<Integer>>  sls = GuessParaType. map (); 
@SuppressWarnings ( "unused" ) 
List<Boolean>  l = GuessParaType. list (); 
@SuppressWarnings ( "unused" ) 
LinkedList<String>  ll = GuessParaType. linkedList (); 
System. out .println(sls.getClass()); 
//function(GuessParaType.list());//此中用法不能用上面有说明 
function (GuessParaType.<Holder_T> list ()); //显示的类型说明 
} 

} 
class  Holder_T  extends  Holder{} 
      
和c++ 一样 Java 也具有可变参数列表： 
package  cn.ccsu.cooole.generics; 

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

/** 
  *   
  *   @author   CoolPrince 
  *   @描述   ： 
  *   可变参数的泛型 
     *   输出： 
  *   [,   a,   b,   c,   d,   e,   f,   g,   h,   j,   k,   l,   m,   n,   o,   p,   q,   r,   s,   t,   u,   * v,   w,   x,   y,   z] 
  */ 
public   class  GenericVarargs { 

    public   static  <T>  List<T>  makeList(T ...args){ 
   List<T> t =  new  ArrayList<T>(); 
    for (T item : args ) 
   { 
   t.add(item); 
   } 
    return  t; 
   } 
public   static   void  main(String[] args) { 

     List<String>  list =  makeList ( "abcdefghjklmnopqrstuvwxyz" .split( "" )); 
     System. out .println(list); 
} 

} 
     
泛型运用于接口当中，只要泛型方法在参数声明为接口，都可以用到该接口的泛型实现的类的对象。方法的泛型在运用于接口的同时也可以运用到内部类当中来，甚至是匿名的类当中。比如一个非常经典的例子银行出纳员服务的问题（这是一个典型的泛型匿名类）： 
return   new  Generator<Teller>(){ 

public  Teller next() { 
return   new  Teller(); 
} 
}; 
     
"好你个擦除，尽然让我这番折腾。 "在学习泛型一章的时候，最感到晕的就是擦除，这个是 Java 泛型的难点，也是泛型的重点的重点。竟然没弄清这个感觉就是学习 Java 遇到了一个大大的障碍。学这个的时候很晕，可以这样说吧，以前很少见到这种情况，主要是没有什么实践经验，这个内容很抽象，初一看，看不出什么名堂，但是硬着头皮学完了这个泛型，就可以说才真正的开始了解（我的实战项目很少，到目前为止觉得自己连菜鸟还不算，也就是一个还为成鸟的蛋，所以不敢大言熟练）。 " 好你个擦除！ " 。 
首先擦除初一看很神秘，在一看的确很神秘，作死的看还是能解开她的一层神秘的面纱。 
探秘擦除： 
1：了解先决条件。什么是擦除？在使用泛型的这个场景的时候，任何具体的类型信息都无法看到，而你唯一知道的就是你在使用一个对象。这个是我个人的理解，可以想象一下，为什么叫擦除。从这问题出发，我个人觉得，就是这个 T 会被别的类型反复的覆盖，主要原因是 Java 运行的是 .class  字节码文件。而且又是一门纯面向对象的语言。因而会产生引用的现象，然而有些时候我们只需要运用到这个通用的方法（只是参数是不定的可以被反复运用），在同一个方法中的同一个参数列表的位置，每执行一次对其后续的传入对象的影响，每个对象的引用传进来时也不受先前的对象的引用的影响，所以就把参数列表的参数进行一次擦除。而在这个过程当中参数列表中的参数只是占了个符号进行标识。（这个是我个人的理解，术语还欠专业，只是为了讲明白这个意思）。 
2：分析需求。为什么要用擦除？擦除的目的实质上时很简单了，从 JDK1.4 到 JDK1.5  的版本内容飞跃， Sun 公司历时 5 年将类库和虚拟机进行完善的这个角度上来分析，也可以从将 JDK1.5 改名为 JDK5.0 。或者从微软的 windows 操作系统来对比。就不难看出，擦除的最初目的就是为了 向后兼容 。因为此前也开发了不少产品，擦除的目的就是让泛型和非泛型进行结合。而擦除的机制使得先后迁移或者说是兼容成为可能，到目前为止也是最好的一种解决方案，以后的话或许还是最好的，但是就不敢说绝对最好了，毕竟技术还在前进。 
3：分析优缺点缺点。擦除有哪些好的理由让它存在比成为设计类库的一个重要机制？还有擦除有哪些实际的问题？先回答第一个：擦除的优点上面 2 有讲到，主要从非泛化到泛化的转变过程，以及在不破坏现有的类库的情况下，将泛型融入到 Java 里边来。擦除使得现有的非泛化的客户端代码能在不改变的情况下继续使用，直到客户端重写了这些代码。例子很容易举，假设有家银行系统是 Java 的非泛型写的，但是它系统又要运行，对于银行的客户或者其他不同权限的系统使用者来讲，要不改变原来的东西，但是在升级的时候将代码重写时就适当运用泛型进行一个过渡。再是第二个问题：擦除的代价也是显而易见的，泛型不能显示的运用于运行时的类型当中。因为此时所有的关于参数类型的信息已经丢失。 
讲到这先看个具体示例：验证擦除后的类型信息的获取。 
  /** 
  *   @author   CoolPrince 
  *   @since   2009 - 7 
  *   @描述   ：擦除的神秘之处 
  *   output:~ 
  *   c1   =    class   java.util.ArrayList 
  *   c2   =    class   java.util.ArrayList 
  *   c1==   c2?true 
  *   class   java.util.ArrayList 
  *   :~ 
  *   形式可以是：Class   c2   =   new   ArrayList <String> ().getClass(); 
  *   虽然可以申明为：ArrayList.class 
  *   但是不能为   Class   c2   =   new   ArrayList <String> ().class; 
  *   也不能为ArrayList <String> .class(); 
  */ 
public   class  ErasedTypeEquivalence { 

/**   
  *   @param   args 
  */ 
public   static   void  main(String[] args) { 
Class c1 =  new  ArrayList<Integer>().getClass(); 
Class c2 =  new  ArrayList<String>().getClass(); 
     print ( "c1 =  " + c1); 
     print ( "c2 =  " + c2); 
     print ( "c1== c2? " + (c1== c2));     
     print (ArrayList. class ); 
} 

public   static   void  print(Object  o){ 
System. out .println(o); 
} 
} 
从上面的注释可以看到，c1 和 c2 的 class 都是 java.util.ArrayList ,所以关于参数 String 和 Integer 的类型信息已经丢失。 

在c++ 模板当中会有这样的几句话： 
template <class   T > 
{ 
    T  object; 
     public  mothod(){object.f();} 
}; 
在c++ 中只管定义，在调用的时候会自动检查 T 类型是否拥有 f() 方法如果没有就会发出异常。 
而在Java 中不能支持这种形式，编译器报错。这个也是 c++ 在类型的参数化方面比 Java 强大的主要原因之一。 
那么Java 中如何实现上述的 C++ 内容呢？具体请看代码及其注释。 

package  cn.ccsu.cooole.generics; 

/** 
  *   
  *   @author   CoolPrince 
  *   @param   <T> 
  *   
  *   在这个示例当中首先要告诉编译器T是什么类型，下面两句   
  *   FunMethodExtendsClass   fmec=   new   FunMethodExtendsClass();   
  *   new   HasFunMethod <FunMethodExtendsClass> (fmec); 
  *   其中传入参数fmec告诉编译器其传的是FunMethodExtendsClass 
  *   
  *   如果将public   HasFunMethod(T   x){object   =   x;}去掉的话 
  *   并且将构造器改为默认的，那么调用hf.testFun()编辑器不能检查到错误 
  *   但是运行的时候就会有空指针异常(java.lang.NullPointerException) 
  */ 
public   class  HasFunMethod<T  extends  FunMethodClass> { 

private  T  object ; 

public   void  testFun() { 
object .fun(); 
} 

public  HasFunMethod(T x) { 
object  = x; 
} 

public   static   void  main(String[] args) { 
FunMethodExtendsClass fmec =  new  FunMethodExtendsClass(); 
HasFunMethod<FunMethodExtendsClass> hf =  
new  HasFunMethod<FunMethodExtendsClass>(fmec); 
hf.testFun(); 

fmec.fun(); 
} 
} 

class  FunMethodClass { 
public   void  fun() { 
System. out .println( "fun()" ); 
} 
} 

class  FunMethodExtendsClass  extends  FunMethodClass {} 

     验证泛型数据的擦除后类型的一致性： 
package  cn.ccsu.cooole.generics; 

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

/** 
  *   @author   CoolPrince 
  *   
  *   @param   <T> 
  *   
  *   将对象传入List   尽管编译器无法知道有关create()中的T的任何类型的信息， 
  *   但是它仍然可以确保   *   你放位置到list的对象具有T类型，使其适合 
  *   ArrayList <T> ,因此,即使擦除在方法或者类的内部移除了有关实际的类型信息， 
  *   编译器仍然可以确保在方法或者类中   使用的类型的内部一致性。 
  *   
  */ 
public   class  FillList<T> { 

public  List<T> create(T t,  int  n) { 
List<T> list =  new  ArrayList<T>(); 
for  ( int  i = 0; i < n; i++) { 
list.add(t); 
} 
return  list; 
} 

public   static   void  main(String[] args) { 
FillList<String> stringMake =  new  FillList<String>(); 

List<String> list = stringMake.create( "cooole" , 4); 
System. out .println(list); 
FillList<Make> make =  new  FillList<Make>(); 
List<Make> list1 = make.create( new  Make(), 3); 
System. out .println(list1); 
} 

} 

class  Make { 
@Override 
public  String toString() { 
return   "make" ; 
} 
} 

     既然擦除有类型信息丢失的现象，我们是否有补救措施？答案当然是有。 
下面是通过引入类型标签解决判定是否可以动态的实例化类的对象。 
package  cn.ccsu.cooole.generics; 

/** 
  *   
  *   @author   CoolPrince 
  *   
  *   输出结果： 
  *   true 
  *   true 
  *   false 
  *   true 
  *   
  *   描述：泛型因为擦除的原因其类型信息就已经擦除了，然而在引入类型标签的话， 
  *   就可以转而使用动态的isInstance()来进行类型的实例化的判断。编译器将确保 
  *   类型标签可以匹配泛型参数。 
  * 
  */ 
public   class  ClassTypeCapture<T> { 

Class<T>  kind ; 
public  ClassTypeCapture(Class<T> kind){ 
this . kind  = kind; 
} 
public   boolean  f(Object o){ 
return   kind .isInstance(o); 
} 
public   static   void  main(String[] args) { 
ClassTypeCapture<Building>  ctc1 =  new  ClassTypeCapture<Building>(Building. class ); 
System. out .println(ctc1.f( new  Building())); 
System. out .println(ctc1.f( new  House())); 

ClassTypeCapture<House> ctc2 =  new   ClassTypeCapture<House>(House. class ); 
System. out .println(ctc2.f( new  Building())); 
System. out .println(ctc2.f( new  House())); 

} 

} 
class  Building{} 
class  House  extends  Building{}  
      
    既然判定对象的是否可以实例化的问题已经解决下面的问题就是实例化对象的操作。 
package  cn.ccsu.cooole.generics; 

public   class  ClassInstantiateGenericType { 
public  ClassInstantiateGenericType() { 
} 

public   static   void  main(String[] args) { 
@SuppressWarnings ( "unused" ) 
ClassAsFactory<Employee> fe =  new  ClassAsFactory<Employee>( 
Employee. class ); 
System. out 
.println( "new ClassAsFactory<Employee>(Employee.class)   is Succeeded" ); 
try  { 
@SuppressWarnings ( "unused" ) 
ClassAsFactory<Integer> fi =  new  ClassAsFactory<Integer>( 
Integer. class ); 
}  catch  (Exception e) { 
System. out 
.println( "new ClassAsFactory<Integer>(Integer.class)  is failed" ); 
} 
} 
} 

class  ClassAsFactory<T> { 
T  x ; 
public  ClassAsFactory(Class<T> kind) { 
try  { 
kind.newInstance(); 
}  catch  (Exception e) { 
throw   new  RuntimeException(e); 
} 
} 
} 

class  Employee { 
} 

这个示例运解决的是一个Java 创建类型实例的一个运用例子，这个是工厂模式。 
而工厂的对象就是Class 对象，所以使用类型标签是十分合理的，而此时只需要将 new Intstance()来实例化并创建这个类型的新对象。 
Java泛型的参数要求所传递类型的构造器是公有默认的构造器。而上面示例 Integer 类没有默认的构造器。 会报J ava.lang.InstantiationException 的错误。  而这个错误并不是在编译期间捕获的所以不建议使用这种方式，下面是这个示例的改良。 

   package  cn.ccsu.cooole.generics; 
/** 
  *   
  *   @author   CoolPrince 
  *   描述：显示工厂的方法解决Java进行泛型类的实例化的问题。 
  *   
  *   主要是限定其类型使得只能接受实现了这个工厂的类 
  *   此时已经获得了编译期间的检查。所以也是比较稳定和安全的 
  */ 
public   class  FactoryConstaint { 
public   static   void  main(String[] args) { 
new   Foo2<Integer>( new  IntegerFactory()); 
new  Foo2< Widget >( new   Widget .Factory()); 
} 

} 
interface  FactoryInterface<T>{ 
T create(); 
} 
class  Foo2<T>{ 
@SuppressWarnings ( "unused" ) 
private  T  x ; 
public  <F  extends  FactoryInterface<T>> Foo2(F factory){ 
x  = factory.create(); 
} 
} 
class  IntegerFactory  implements  FactoryInterface<Integer>{ 
public  Integer create() { 
return   new  Integer(10); 
} 

} 
class   Widget { 
public   static   class  Factory  implements  FactoryInterface< Widget >{ 
public   Widget  create() { 
return   new   Widget (); 
} 

} 
} 

   既然显示工厂可以解决此问题，那么还有其他的解决途径没有？模板方法设计模式。 
package  cn.ccsu.cooole.generics; 

/** 
  *   
  *   @author   CoolPrince 
  *   模板模式解决Java泛型类额实例化问题 
  *   通过这种方式可以获取类型的信息 
  */ 
public   class  CreatGenerics { 


public   static   void  main(String[] args) { 
Createor c =  new  Createor(); 
c.f(); 
} 
} 
abstract   class  GenericWithCreate<T>{ 
final  T  elements ; 
GenericWithCreate(){ elements  = create(); 
} 
abstract  T create();  
} 
class  ClassX{} 
class  Createor  extends  GenericWithCreate<ClassX>{ 
@Override 
ClassX create() { 
return   new  ClassX(); 
} 
public   void  f(){ 
System. out .println( elements . getClass ().getSimpleName()); 
} 

} 


 泛型在数组中的运用: 一般的解决方案都是在任何想要创建泛型数组的地方都用 ArrayLis 进行替代。这样既能获得数组的行为也能获得由编译器提供的编译器类型的安全。 
  直接创建数组不会发出任何警告。却也永远无法创建这个确切的数据类型数组，直接进行转化就会抛出异常。 
 有一种方式。也是唯一的一中方式就是：利创建一个被擦除类型的新数组。然后转型。 
具体示例见下文： 
private  T[]  array ; 
public  GenericsArray( int   size ){ 
array  = (T[])  new  Object[size]; 
} 
这种形式是不行的尽管它在初学者看来和直观，当其对返回值进行转型的时候就会有一个叫做ClassCastException; 此时实际运行的是 Object[]; 
因为有了擦除，数组的运行时类型就只能是Object[], 如果我们立即将其转型为 T[], 那么编译期间的实际类型就会丢失，而编译器可能会错过某些潜在的错误检查。所以最好的方式是在集合内部使用 Object[], 然后当你使用数组元素的时候，添加一个 T 的转型。 
package  cn.ccsu.cooole.generics; 

/** 
  *   
  *   @author   CoolPrince 
  * 
  *   @param   <T> 
  *   
  *   输出：   [Ljava.lang.Object;@de6ced 
  *   所以还是存在类型的丢失问题，当调用这个gai.getArray()的其他方法的时候 
  *   编译器也会报告异常。 
  */ 
public   class  GenericsArray2<T> { 
private  Object[]  array ; 

@SuppressWarnings ( "unchecked" ) 
public  GenericsArray2( int  size){ 
array  = (T[])  new  Object[size]; 
} 
@SuppressWarnings ( "unchecked" ) 
public  T[] getArray(){ 
return  (T[]) array ; 
} 
public   void  put( int  index, T  item){ 
array [index]  = item; 
} 
public   static   void  main(String[] args) { 
GenericsArray2<Integer> gai =  new  GenericsArray2<Integer>(10); 
for ( int  i = 0;i<10;i++){ 
gai.put(i, i); 
} 
    System. out .println(gai.getArray()); 

} 

} 

   难道真的没有其他办法来解决这一难题。 
先看看下面的反射再说： 
    package  cn.ccsu.cooole.generics; 

import  java.lang.reflect.*; 

/** 
  *   @author   CoolPrince 
  * 
  *   @param   <T> 
  *   
  *   输出结果： 
  *    class   [Ljava.lang.Integer; 
  *    0   1   2   3   4   5   6   7   8   9 
  *    
  *    类型标记Class <T> 被传送到构造器中，以便恢复，使得我们可以创建需要的实际的类型的数组 
  *    尽管@SuppressWarnings("unchecked")压制警告，一旦获得实际的类型就可以进行返回 
  *    
  */   
public   class  GenerArrayWithTypeToken<T> { 
@SuppressWarnings ( "unused" ) 
private  T[]  array ; 
@SuppressWarnings ( "unchecked" ) 
public  GenerArrayWithTypeToken(Class<T> type,  int  size) { 
array  = (T[]) Array. newInstance (type, size); 

} 
public   void  put( int  index, T item) { 
array [index] = item; 
} 
public  T get( int  index) { 
return   array [index]; 
} 
public  T[] getArray(){ 
return  (T[]) array ; 
} 
public   static   void  main(String[] args) { 
GenerArrayWithTypeToken<Integer> gawti =  new   GenerArrayWithTypeToken<Integer>( 
Integer. class , 10); 
for ( int  i = 0;i<10;i++){ 
gawti.put(i, i); 
} 
Integer [] ia  = gawti.getArray(); 
System. out .println( ia .getClass()); 
for ( int  i = 0;i<10;i++){ 
   System. out .print( " " +  ia [i]); 
}         
} 
} 

既然Java 的泛型可以如此神通广大，我们有什么方法对其进行一定的限制提高它的性能呢 ? 答案便是边界！ 
package  cn.ccsu.cooole.generics; 

import  java.awt.Color; 

/** 
  *   @author   CoolPrince 
  * 
  *   @param   <T> 
  *   
  *这个事例主要是分析边界及其继承关系的相关理论。 
  *   边界实质上就是在泛型上设置限制条件。这个限制强制了所要使用的类型范围 
  *   但是一个潜在的好处就是可以按照自己定义的边界来调用方法。比如说： 
  *   int   weigth(){ 
  * return   item.weigth(); 
  * } 
  *在此时已经保障了inem.weigth()的存在性。   因为这条语句 
  *<T extends Dimension & HasColor & Weigth> 
  *要求必须实现Weight接口 
  *这个地方也有个小的策略，就是先将类放到extends的后面然后就是接口口，尽量将方 
* 法多的， 
  *或者是子类放到靠前面一些这样就会有一定的效率提高，其次限制时没有implements 
 * 而是将 
  *extends代替，这个是Java的设计者考虑到extends能够更好的表意所以统一采用这种 * 形式 
  *此时的extends和平时的用法是完全不同的。 
  */ 
public   class  GenericInheritBaseBounds<T> { 
public   static   void  main(String[] args) { 
@SuppressWarnings ( "unused" ) 
Solid<Bounded> sb =  new  Solid<Bounded>( new  Bounded()); 
System. out .println(sb.getX()); 
System. out .println(sb. weigth ()); 
System. out .println(sb.getItem().getClass()); 
} 
} 
interface  HasColor{java.awt.Color  getColor();} 
interface  Weigth{ int  weigth();} 
class  HoldItem<T>{ 
T  item ; 
HoldItem(T item){ this . item  = item;} 
T getItem(){ return   item ;} 
} 
class  Dimension{ public   int   x , y , z ;} 

class  Colored<T  extends  HasColor>  extends  HoldItem<T>{ 
Colored(T item){ super (item);} 
} 
class  ColorDimension<T  extends  Dimension & HasColor>  extends  Colored<T>{ 
ColorDimension(T item) { super (item);} 
int  getX(){ return   item . x ;} 
} 
class  Solid<T  extends  Dimension & HasColor & Weigth>  extends  ColorDimension<T>{ 
Solid(T item) { super (item);} 
int   weigth (){ 
return   item .weigth(); 
} 
} 
class  Bounded  extends  Dimension  implements   HasColor,Weigth{ 

public  Color getColor() { 

return  Color. black ; 
} 
public   int  weigth() { 
return  10; 
} 
} 
  
泛型通配符： 
泛型一个主要目标是将运行时可以发现插入不正确的数据类型的错误信息检测移入到编译期。 
下面的几个示例就是讨论通配符的相关的问题：主要是总结那些情况下可以用，那些情况下有缺陷，哪些情况下可以进行优化。 
首先简述数组的一种特殊的行为：可以向导出类型的数组赋予基类型数组引用。假设有这样一种情况：基类蔬果(Fruit), 其有两个子类苹果（ Apple ）、桔子（ Orange ） , 另外又有苹果类又有一个子类 --- 李子苹果（ PlumApple ）的杂交苹果。 
Fruit []  fruit  =  new  Apple[10]; 那么 fruit[0] =  new  Apple(); 
fruit[0] =  new  PlumApple(); 都是合法的因为他们都是Apple 的子类，然而 new   Fruit (),或者是非苹果的子类都会报告数组存储错误的异常。为什么会有这种情况的出现呢？虽然有个 Fruit []  fruit 数组的引用，在编译期间就算你new Orange() 也不会报告异常，但是在运行期间 Java 还是会根据数组的基本机制将其处理成 Apple[], 因此在数组中放入异构型的数组时就会有异常。数组有一个重大的好处就是他可以保留有关他们的包含的对象的类型的信息规则。一般这样说，数组对其持有的对象是有意识，因此在编译期间一定要做检查，否则就会造成滥用的情况的发生。那么用 List<Fruit> f =  new   ArrayList <Apple>(); 来可以吗？不行两个泛化的参数必须一致， List<Fruit> 的对象将持有所有 Fruit 的所有的Fruit 对象也包括 Apple 。但是这里的情况 List<Fruit> 的对象和 List< Apple > 的对象时不同的，这个地方和多态是有区别的，从多态的单个来讲 Fruit f = new Apple(); 是可以的允许的而且此时持有的也是 Apple 的对象，加了个 List 容器就不同了。为什么这样讲呢？理论上时这样讲的：这里是讲的容器的类型而不是容器所持有的类型。也就是上面那句话所描述的那样。 
现在假设有另一种情况假设缴入了边界的限制又会怎样呢？形式如 List<?  extends  Fruit> = new ArrayList<Apple>();又能行吗？你先自己编一下。答案告诉我们这种方式是行不通的。此时定义为 new ArrayList<Apple>() ，如果可以的话那么  new ArrayList<Orange>() 也是安全可行的，但是这样的话岂不是很混乱。在不知道 List 持有什么样的类型时候是不能向其中添加任何对象的（除了 null ）。所以必须明确 List 持有对象的类型。那么这样的形式岂不是毫无用处。实际上也不补完全是这样，如果你调用 Fruit 类的方法还是不会报异常，也是安全的，因为此时在 List 持有的对象中至少具有 Fruit 的类型，此时编译器是允许这样做的。就拿 List<?  extends  Fruit> 来说，编译器并不知道是Fruit 的具体的哪个类。 ?  extends  Fruit 意味着可以是任何类型的事物，同时编译器又无法验证它的安全性。这个地方还是有严格限制的。 
说白了泛型要知道具体的持有的对象的参数，至少也要通过反射来告诉编译器是个什么东东，在泛化的过程中利用类型标签来实现工厂模式，模板模式来解决泛型是非常有用的。 

既然有继承的统配符是否有超类的通配符来进行类型的限定？ 
超类的通配符的语法<? super SuperClassName>,<? s extends  SubClassName> 是上界，而超类的通配符就是我们所说的下界。另外还有个叫无界 <?>, 下面也将讲到。 
package  cn.ccsu.cooole.generics; 

import  java.util.Arrays; 
import  java.util.List; 

/** 
  *   
  *   @author   CoolPrince 
  * 
  *   输出： 
  *   fun1()   f.getClass():   class   cn.ccsu.cooole.generics.Apple 
  *   fun1()   a.getClass():   class   cn.ccsu.cooole.generics.Apple 
  *   fun2()   f.getClass():   class   cn.ccsu.cooole.generics.Fruit 
  *   fun3()   f.getClass():   class   cn.ccsu.cooole.generics.Fruit 
  *   fun3()   a.getClass():class   cn.ccsu.cooole.generics.Apple 
  *   
  *   先从输出来对其原理进行深层次分析： 
  *   fun1()中调用的readExact();参数已经进行类限制，并没有进行通配 
  *   此时编译编译器就会根据实际的类型进行调用和传参，只是此时在编译期间 
  *   进行强制的类型检查，避免了许多的错误，而不会出现可以是任何事物的 
  *   情况而使得编译器不知道如何处理。 
  *   在fun2()中由于Reader <Fruit>   fruitReader   =   new   Reader <Fruit> (); 
  *   的限制而无法将Apple   作为类型进行检查，此时的注释部分是不能运行的（编译期 
  *   间就有错误）。 
  *   在fun3()中则运用了？extends进行通配   此时只要是Fruit的子类就可以传进来只 
  *   要将其返回值为Fruit就行，其实此时已经是Apple的引用。故而有上述的显示结果。 
  */ 
public   class  GenericReading { 

static   class  CovariantReader<T> { 
T readCovariant(List<?  extends  T> list) { 
return  list.get(0); 
} 
} 

static   class  Reader<T> { 
T readExact(List<T> list) { 
return  list.get(0); 
} 
} 

static  List<Apple>  apples  = Arrays. asList ( new  Apple()); 

static  List<Fruit>  fruits  = Arrays. asList ( new  Fruit()); 

static   void  fun1() { 
@SuppressWarnings ( "unused" ) 
Apple a =  readExact ( apples ); 
Fruit f =  readExact ( fruits ); 
f =  readExact ( apples ); 
System. out .println( "fun1() f.getClass(): "  + f.getClass()); 
System. out .println( "fun1() a.getClass(): "  + a.getClass()); 
} 

static   void  fun2() { 
Reader<Fruit> fruitReader =  new  Reader<Fruit>(); 
Fruit f = fruitReader.readExact( fruits ); 
System. out .println( "fun2() f.getClass(): "  + f.getClass()); 
// Fruit a = fruitReader.readExact(apples); 
} 

static   void  fun3() { 
CovariantReader<Fruit> crf =  new  CovariantReader<Fruit>(); 
Fruit f = crf.readCovariant( fruits ); 
Fruit a = crf.readCovariant( apples ); 
System. out .println( "fun3() f.getClass(): "  + f.getClass()); 
System. out .println( "fun3() a.getClass():"  + a.getClass()); 
} 

public   static   void  main(String[] args) { 
fun1 (); 
System. out .println(); 
fun2 (); 
System. out .println(); 
fun3 (); 
} 

static  <T> T readExact(List<T> list) { 
return  list.get(0); 
} 

} 
    <?>可以笨认为是一种装饰，但是它仍然具有一定的实际价值，在实际看来： " 我想用Java 的泛型编写这段代码 , 我这里并不是要用原生类型，但是在当前的情况下泛型可以持有任何类型。 " 
     泛型通配符，以List 为例 List<Object> 与 List<?> 是有区别的， List 实际上时表示 " 持有任何 Object 类型的原生 List", 而 List<?> 表示 " 具有某种特定类型的非原生List 只是我们不知道那种类型是什么。 " 
    当泛型过于受限的时候就应该考虑通配符，这主要取决于泛型的参数中返回类型确定的返回值。 
因此运用确切类型来替代通配符的好处是：可以用泛型的参数来处理更多的事情，但是使用通配符使得你必须接受范围更加宽的参数化类型作为参数。 
那么什么时候使用通配符比使用原生的更好或者说是更加需要。那就是我们通常所说的捕获转换这个还真的是非常需要。 
捕获转化的定义: 如果向一个使用<?> 的方法传递原生类型，那么是对于编译器来说，可能会推断出实际的类型参数 ( 运用反射就可以得到 ) ，使得这个方法可以回转并调用另一个使用这个确切类型的方法（事实上泛型参数擦除的是第一边界，这个情况是一定的）。 
下面这个例子足以对其进行说明( 详见上面一段话结合程序进行理解，也对注释特别留意，并慢慢体会 ) 。 
package  cn.ccsu.cooole.generics; 
/** 
  *   
  *   @author   CoolPrince 
  *   @param   <T> 
  *   泛型示例   
  */ 
public   class  Holder_3<T> { 

public  Holder_3(T a){ this . a  = a;} 
public  T get(){ return   a ;} 
public   void  set(T a){ this . a  = a;} 
public  Holder_3(){} 

public   static   void  main(String[] args) { 
Holder h =  new  Holder(); 
Holder_3<Holder>  h3 =  new  Holder_3<Holder>(h);  
System. out .println(h3); 
Holder hh = h3.get(); 
System. out .println(hh); 
/*h3.set("cooole"); //h3已经限定了其类型为Holder所以其他类型 
  h3.set(new Integer(1));//比如StringInteger还是其他非Holder类   型都是不允许传进来类型参数的 
      */ 
} 
private  T  a ; 
} 


package  cn.ccsu.cooole.generics; 

/** 
  *   
  *   @author   CoolPrince 
  *   捕获转化举例： 
  *   先看输出结果： 
  *   Integer 
  *Integer 
  *Object 
  *Double 
  *   再看   main方法： 
  *   Holder_3   h3t   =   new   Holder_3 <Integer> (23); 
  *   定义一个Holder_3   h3t   类型参数为Integer 
  *   此时调用方法method1();就会输出类型名：Integer 
  *   调用方法menthod2()的时候里面传进来方法method1   的参数 
  *   此时就会被擦除从而带入到method2中，故而会有上面的结果。 
  *   这个过程通过参数的传递来进行捕获转化。此时的通配符就派上了用场 
  *   
  */ 
public   class  CaptureConversion { 
static  <T>   void  method1(Holder_3<T> holder){ 
T t = holder.get(); 
System. out .println(t.getClass().getSimpleName()); 
} 
static   void  method2(Holder_3<?> holder){ 
method1 (holder); 
} 

@SuppressWarnings ( "unchecked" ) 
public   static   void  main(String[] args) { 
Holder_3 h3t =  new  Holder_3<Integer>(23); 
method1 (h3t); 
method2 (h3t); 
Holder_3 h3t2 =  new  Holder_3(); 
h3t2.set( new  Object()); 
method2 (h3t2); 

Holder_3<?> wildcard =  new  Holder_3<Double>(23.0); 
method2 (wildcard); 
} 
} 

泛型没有消除对对象转型的需要。 
package  cn.ccsu.cooole.generics; 

public   class  FixedStack<T> { 

private   int   index   = 0; 
private  Object[]  storage ; 
public  FixedStack( int  size){  
storage  =  new  Object[size]; 
} 
public   void  push(T item){ 
storage [ index ] = item; 
index ++; 
} 
@SuppressWarnings ( "unchecked" ) 
public  T pop(){ 
return  (T)  storage [ index --]; 
} 
public   static   void  main(String[] args) { 
FixedStack<Integer>  ii =  new  FixedStack<Integer>(11); 
for ( int  i = 1;i<=10;i++){ 
ii.push(2*i); 
} 
 ii.pop(); 
System. out .println(ii.pop().getClass().getSimpleName()); 
} 
} 

泛型没有消除对对象转型的需要，从pop ()中的强制转化，没转化前还是 Object 。 

    实现参数化接口： 
interface  Payable<T>{} 
class  Emplyee  implements  Payable<Emplyee>{} 
c lass   Hourly   extends  Emplyee  implements  Payable< Hourly >{} 
在这个实例当中最后一条语句由于擦除的原因，这两个变体会成为相同的借口而产生冲突。如果将 Payable<T> 的参数类型移除就能够通过编译。 
对于泛型重载，由于擦除的缘故，重载类型的方法将产生类型相同的签名，当被擦除的参数不能产生唯一的参数列表时，必须提供有明显区别的方法名。 
Java自限定类型： 
package  cn.ccsu.cooole.generics; 

/** 
  *   
  *   @author   CoolPrince 
  *   自限定的基本语法如同： 
  *   class   SelfBounded<T extends SelfBounded<T>> 
  *   自限定限制只能强制作用于继承关系，如果使用自限定就必须了解这个 
  *   类所用的类型参数将与使用这个参数的类具有相同的基类型。 
  *   
  */ 
public   class  SelfBounding { 

public   static   void  main(String[] args) { 
A a =  new  A(); 
System. out .println(a.getClass()); 
a.set( new  A()); 
System. out .println(a.getClass()); 
a = a.set( new  A()).get(); 
System. out .println(a.getClass()); 
B b =  new  B();  
System. out .println(b.getClass()); 
C c =  new  C(); 
c = c.setAndGet( new  C()); 
System. out .println(c.getClass()); 
} 
} 
class  SelfBounded<T  extends  SelfBounded<T>>{ 
T  element  ; 
SelfBounded<T> set(T  arg ){ 
element  =  arg ; 
return   this ; 
} 
T get(){ return   element ;} 
} 
class  A  extends  SelfBounded<A>{} 
class  B  extends  SelfBounded<A>{} 
class  C  extends  SelfBounded<C>{ 
C setAndGet(C arg){  
set(arg); 
return  get(); 
} 
} 
    其实Java 的自限定类型的价值在于他们可以产生协变参数类型——方法参数类型会随着子类而进行变化（类型雨来与严格也就是擦除第一边界所引起的），自限定类型还可以产生于基类类型相同的返回类型。 
    
package  cn.ccsu.cooole.generics; 

/** 
  *   
  *   @author   CoolPrince   输出结果：   
  *   cn.ccsu.cooole.generics.ImplmentsGetter@61de33 
  *   cn.ccsu.cooole.generics.ImplmentsGetter@61de33 
  *   
  *   cn.ccsu.cooole.generics.ImplmentsGetter_1@ca0b6 
  *   cn.ccsu.cooole.generics.ImplmentsGetter_1@ca0b6 
  *   
  *   此时从输出可以见到我们所谓的动态绑定的效果 
  *   这个时候就可以看到参数协变的效果。 
  *   和普通的继承一样了，不信得话可以讲类型数去掉后在去观察结果 
  *   已经重载了方法get(); 
  */ 
public   class  GenericsAndReturnType { 

public   static   void  main(String[] args) { 
ImplmentsGetter ig =  new  ImplmentsGetter(); 
test (ig); 
System. out .println(); 
ImplmentsGetter_1 ig1 =  new  ImplmentsGetter_1(); 
test (ig1); 

} 

static   void  test(Getter g) { 
@SuppressWarnings ( "unused" ) 
Getter res = g.get(); 
System. out .println(res); 
@SuppressWarnings ( "unused" ) 
GenericGetter gg = g.get(); 
System. out .println(gg); 
} 
} 

interface  GenericGetter<T  extends  GenericGetter<T>> { 
T get(); 
} 

interface  Getter  extends  GenericGetter<Getter> { 
} 

class  ImplmentsGetter  implements   Getter  { 

public  Getter  get () { 
return   this ; 
} 
} 

class  ImplmentsGetter_1  extends  ImplmentsGetter { 
} 

动态类型安全问题分析： 
    受检查的容器在你试图插入类型不正确的数据时就会，抛出ClassCastExcption, 这与泛型之前的原生的容器形成了鲜明的对比，对于后者来说，当你将对象从容器中取出的时候才会通知你出现了问题，此时尽管你直到出现了问题但是你不知道问题在哪，如果使用受检查的容器就会在编译期间发现插入不良的对象。 
  
既然泛型在编译期间的安全问题自行可以解决，那么在运行期间的异常又该如何处置呢？ 
可以采用这种方式： 
 Class TestClass<T,E extends Exception>{ 
   public  void f() throws E{} 
} 
当然参数E 也可以是其他自定义继承非 Throwable 的类。 
其他的和上面的基本相同。 

   在擦除忘记其比本类型，所以泛型类不能直接继承自一个泛型的参数。 
故而产生了另外一种解决方案，说白了就是用类来继承混合接口的实现，来实现混型的机制。 
例子很简单，只是代码稍微有些长： 
  package  cn.ccsu.cooole.generics; 

import  java.util.Date; 
/** 
  *   @author   CoolPrince 
  */ 
public   class  Mixins { 

public   static   void  main(String[] args) { 
Minin minin1 =  new  Minin(), minin2  =  new  Minin(); 
minin1.set( "测试 String 1" ); 
minin2 .set( "测试 String 2" ); 
System. out .println(minin1.get()+ " " +minin1.getSerialNumber()+minin1.getStamped()); 
System. out .println( minin2 .get()+ " " + minin2 .getSerialNumber()+ minin2 .getStamped()); 

} 

} 
interface  TimeStamped{ public   long  getStamped();} 
interface  SerialNumbered{ public   long  getSerialNumber();} 
interface  Basic{ 
public  String get(); 
public   void  set(String val); 
} 
class  TimeStampImp  implements  TimeStamped{ 

private   final   long   timeStamp ; 
TimeStampImp(){ 
timeStamp  =   new  Date().getTime(); 
} 
public   long  getStamped() { 
return   timeStamp ; 
} 
} 
class  BasicImp  implements  Basic{ 
    
String  value ; 
public  String get() { 
return   value ; 
} 
public   void  set(String val) { 
value  = val; 
} 
} 
class  SerialNumberedImp  implements  SerialNumbered{ 

private   static   long   counter = 1; 
public   long  getSerialNumber() { 
return   SerialNumber ; 
} 
private   final   long   SerialNumber  =  counter ++; 

} 
/** 
  *   
  *   @author   CoolPrince 
  *   典型的混型代理 
  */ 
class  Minin  extends  BasicImp  implements  TimeStamped,SerialNumbered{ 

private  TimeStamped  timeStamp  =  new  TimeStampImp();  
private  SerialNumberedImp  serialNumberedImp  =  new  SerialNumberedImp(); 
public   long  getStamped() { 
return   timeStamp .getStamped(); 
} 
public   long  getSerialNumber() { 
return   serialNumberedImp .getSerialNumber(); 
} 

} 

 似乎从上面的这个例子就好像与泛型搭不上边了，在这里先要特别注意泛型是数据类型的一个基本要素，下面介绍一下与泛型或者混型有关的几个基本的设计模式： 
1：装饰器模式（这个模式在类库里用的非常多，不知你对装饰器有无了解，其中一个重要的库的主要思想就是装饰器模式，在尚学堂的视频里讲的那个管道就是装饰器模式的一种说法，我也是后来看源码才知道的），那就先不分析那些 Buffered 和 Data ，留到下篇文章讲 I/O 的时候来分析部分源码来讲解装饰器模式。 
先看个简单的例子： 
      package  cn.ccsu.cooole.generics.decorator; 

import  java.util.Date; 

/** 
  *   
  *   @author   CoolPrince   这个就是一个典型的装饰器设计模式的运用   
  *            仔细看是不是一层套一层。 
  *           装饰器模式是使用的分层对象来态透明的向单个对象中添加责任。装饰器指定   
  *           包装在最初的对象的周围所有的对象具有相同的接口。某些事物是可以装饰的 
  *           可以通过将其他类包装在可装饰的对象的四周，来将其分层。所以无论对象是   
  *           否有装饰你都可以拥有一个可以向对象发送公共消息集。当然装饰类也可以 
  *           添加新的方法，但是这也是受限的。   混型和装饰器模式及其类似但是装饰器 
  *           并不需要装饰器的继承结构（运用代理） 
  *   
  */ 
public   class  DecorationMode { 
public   static   void  main(String[] args) { 
TimeStamped t =  new  TimeStamped( new  Basic()); 
TimeStamped t2 =  new  TimeStamped( new  SerialNumbered( new  Basic())); 
SerialNumbered s =  new  SerialNumbered( new  Basic()); 
SerialNumbered s2 =  new  SerialNumbered( new  TimeStamped( new  Basic())); 
System. out .println(t); 
System. out .println(t2.getStamp()); 
System. out .println(s.getSerialNumber()); 
System. out .println(s2); 
} 

} 

/** 
  *   
  *   @author   CoolPrince   基类型 
  */ 
class  Basic { 
private  String  value ; 

public   void  set(String val) { 
value  = val; 
} 

public  String get() { 
return   value ; 
} 
} 

/** 
  *   
  *   @author   CoolPrince   注意   protected这个修饰符表示的是具有包以及继承层次的子类拥有访问权限 
  *           这个地方Decrator拥有类Basic   属于代理 
  */ 
class  Decrator  extends  Basic { 
protected  Basic  basic ; 

public  Decrator(Basic basic) { 
this . basic  = basic; 
} 

public   void  set(String val) { 
basic .set(val); 
} 

public  String get() { 
return   basic .get(); 
} 
} 

/** 
  *   
  *   @author   CoolPrince   必须拥有构造器   getStamp()是新添加的   这个地方TimeStamped拥有类Decrator   属于代理 
  */ 
class  TimeStamped  extends  Decrator { 
public  TimeStamped(Basic basic) { 
super (basic); 
time  =  new  Date().getTime(); 
} 

public   long  getStamp() { 
return   time ; 
} 

private   final   long   time ; 
} 

class  SerialNumbered  extends  Decrator { 

public  SerialNumbered(Basic basic) { 
super (basic); 
} 

private   static   long   counter  = 1; 

public   long  getSerialNumber() { 
return   SerialNumber ; 
} 

private   final   long   SerialNumber  =  counter ++; 

} 

Java  并不支持潜在的类型机制，所以看上去不是非常的泛化。在c++ 中即便是一个不知道的类型  T  也可以调用它的方法只不过在传入类型参数的时候会进行检查看是否具有该方法。而 Java 对这个并不支持。它主要还是通过实现接口来继承类来实现这个机制的功能。尽管 Java 缺乏潜在类型的机制，但是还是有多种补救的措施： 反射 。上面也讲过通过反射来进行类型标签。 
第二个就是将一个方法运用于序列（略） 
适配器模式举例： 
package  cn.ccsu.cooole.generics; 

import  java.util.*; 

/** 
  *   
  *   @author   CoolPrince 
  *   适配器模式举例： 
  *   运行结果： 
  *   Adpter.num   =   0 
  *   Adpter.num   =   1 
  *   Adpter.num   =   2 
  *   Adpter.num   =   3 
  *   Adpter.num   =   4 
  *   Adpter.num   =   5 
  *   Adpter.num   =   6 
  *   Adpter.num   =   7 
  *   这个例子主要是通过Collection来进行适配 
  *   
  */ 
public   class  AdapterMode1 { 

public   static   void  main(String[] args) { 
         List<AdpterTmp> li =  new  ArrayList<AdpterTmp>(); 
         Fill2. fill ( new  AddableCollectionnAddapter<AdpterTmp>(li), AdpterTmp. class , 4); 
         Fill2. fill (Adapter. collectionAdapter (li), AdpterTmp. class , 5); 
          for (AdpterTmp i:li){ 
          System. out .println(i); 
         }          
} 

} 
interface  Addable<T>{ void  add(T t);} 

class  Fill2{ 
public   static  <T>  void  fill(Addable<T> addable,Class<?  extends  T> classToken, int  size){ 
for ( int  i = 0; i<size;i++){ 
try  { 
addable.add(classToken.newInstance()); 
}  catch  (Exception e) { 
    throw   new  RuntimeException(e); 
} 
} 
} 
} 
class  AddableCollectionnAddapter<T>  implements  Addable<T>{ 

private  Collection<T>  c ; 
AddableCollectionnAddapter(Collection<T> c){ 
this . c  = c; 
} 
public   void  add(T t) { 
c .add(t); 
} 
} 
class  Adapter{ 
public   static  <T>  Addable<T>  collectionAdapter(Collection<T> c){ 
return   new  AddableCollectionnAddapter<T>(c); 
} 
} 
class  AdpterTmp{ 
static   int   counter  = 0;  
private   final   int   num  =  counter ++; 
public  String toString(){ 
return   "Adpter.num = " +  num ; 
} 

} 
这个例子描述了适配器创建了真正泛化的代码。 

策略设计模式 

package  cn.ccsu.cooole.generics; 

import  java.math.BigDecimal; 
import  java.math.BigInteger; 
import  java.util.ArrayList; 
import  java.util.Iterator; 
import  java.util.*; 
import  java.util.concurrent.atomic.AtomicLong; 



/** 
  *   
  *   @author   CoolPrince 
  *   策略设计模式： 
  *   
  */ 
public   class  StrategyModel { 


public   static  <T> T reduce(Iterable<T> seq,Combiner<T> combiner){ 
Iterator<T> it = seq.iterator(); 
T result =  null ; 
if (it.hasNext()){ 
result = it.next(); 
while (it.hasNext()){ 
result = combiner.combine(result, it.next()); 
} 

} 
return  result; 
} 
public   static  <T> Collector<T> forEach(Iterable<T> seq, Collector<T> func){ 
for (T t:seq){ 
func.function(t); 
} 
return  func; 
} 
public   static  <R,T> List<R> tansform(Iterable<T> seq,UnaryFunction<R, T> func){ 
List<R> result =  new  ArrayList<R>(); 
for (T t:seq){ 
result.add(func.function(t)); 
} 
return  result; 
} 
public   static  <T> List<T> filter(Iterable<T> seq,UnaryPredicate<T> pred){ 
List<T> result =  new  ArrayList<T>(); 
for (T t:seq){ 
if (pred.test(t)){ 
result.add(t); 
} 
} 
return  result; 
} 

static   class  IntegerAdder  implements  Combiner<Integer>{ 
public  Integer combine(Integer x, Integer y) { 
return  x+y; 
} 

} 
static   class  IntegerSubtracter  implements  Combiner<Integer>{ 

public  Integer combine(Integer x, Integer y) { 
return  x-y; 
}    
} 

static   class  BigDecimalAdder  implements  Combiner<BigDecimal>{ 

public  BigDecimal combine(BigDecimal x, BigDecimal y) { 
return  x.add(y); 
} 
} 

static   class  BigIntegerAdder  implements  Combiner<BigInteger>{ 

public  BigInteger combine(BigInteger x, BigInteger y) { 
return  x.add(y); 
} 
} 
static   class  AtomicLongAdder  implements  Combiner<AtomicLong>{ 

public  AtomicLong combine(AtomicLong x, AtomicLong y) { 
return   new  AtomicLong(x.addAndGet(y.get())); 
} 
} 
static   class  BigDeimalUlp  implements  UnaryFunction<BigDecimal, BigDecimal>{ 
public  BigDecimal function(BigDecimal x) { 
return  x.ulp(); 
} 
} 
static   class  Greaterthan<T  extends  Comparable<T>>  implements  UnaryPredicate<T>{ 
private  T  bound ; 
public  Greaterthan(T bound){ 
this . bound  = bound; 
} 
public   boolean  test(T x) { 
return  x.compareTo( bound ) > 0; 
} 
} 
static   class  MultiplyingIntegerCollector  implements  Collector<Integer>{ 
private  Integer  val  = 1; 
public  Integer function(Integer x){ 
val *= x; 
return   val ; 
} 
public  Integer result() { 
return   val ; 
} 
} 

public   static   void  main(String[] args) { 
          List<Integer>  list = Arrays. asList (1,2,3,46); 
          Integer res =   reduce (list, new  IntegerAdder()); 
          System. out .println(res); 
           
          res =  reduce (list,  new  IntegerSubtracter()); 
           print (res); 
           
           print ( filter (list, new  Greaterthan<Integer>(4))); 
           
           print ( forEach (list, new  MultiplyingIntegerCollector()).result()); 
           print ( forEach ( filter (list, new  Greaterthan<Integer>(4)), new  MultiplyingIntegerCollector()).result()); 
           print ( "" ); 

} 
public   static   void  print(Object obj){ 
System. out .println(obj); 
} 

} 
interface  Combiner<T> {T combine(T x,T y);} 
interface  UnaryFunction<R,T>{ R function(T x);} 
interface  Collector<T>  extends  UnaryFunction<T, T>{T result();} 
interface  UnaryPredicate<T>{ boolean  test(T x);} 



后话： Java 的泛型机制最吸引人的地方就是在使用容器类的地方，泛型的核心是重用和解决一些多态无法解决的问题，泛型的表达意识很强，所以又很好的可读性。泛型的内容比较丰富，最重要的是理解什么是泛型，为什么使用，有哪些缺陷，值得注意的原理是什么（比如擦除），有哪些设计模式在泛型中运用广泛，总之泛型看上去很糟糕但是在大型的运用中间还是比较广的小的运用中，一般情况用的多的也就是容器。总算总结完了，真的写这篇文章就花了整整 4 天的时间，确实泛型和并行是 Java 的两大难点，感觉学了泛型之后慢慢对以前写过的东西有所反思，很多地方都可以用泛型进行简化，从而减少了代码量。学习技术是个过程，现在慢慢有所体会学习技术是不可能一蹴而就的，也不能存在投机的心理，这样才能一步一个脚印。其实再写这篇文章的时候很想不在继续写下去了，但是后来一想，决定的事还是慢慢干下去，不然学的东永远只是皮毛。学习的进度只有计划的 1/3; 但是话有说回来，学技术不能光赶进度。有一句话说的好：什么是技术牛人，就是你的学习进度永远在别人的前面，别人学的是你已经学过的东西。是的，我的这篇文章很大一部分都是书上的一些基本的原理，其中也大量参杂了个人的一些见解和对程序的领悟。四天的时间来写这个论文我还是觉得没有浪费，尽管效率不是很高，如果谁看到这篇总结的文章能将其看完那么这个人也是一个能坚持住的人，不说别的泛型也能上升一个层次了。时候不早了，就此住笔。