generic

一、       Introduction

Java泛型是java se 1.5的新特性，泛型的本质是参数化类型，指所操作的数据类型被指定为一个参数。泛型可以在类、接口和方法中创建，分别称为泛型类、泛型接口、泛型方法。使用泛型的好处是安全简单，可以将运行时错误提前到编译时错误。

二、       集合中使用泛型

List中使用泛型

   public voidtest1(){

      List<String> l=new ArrayList();

      l.add("看看");

      l.add("浏览");

      //l.add(12);

      for(Iterator i=l.iterator();i.hasNext();){

         System.out.println(((String)i.next()).length());

      }

   }

Set中使用泛型

创建自定义类

public class User {

   private String name;

   private intage;

   public String getName() {

      return name;

   }

   public voidsetName(String name){

      this.name = name;

   }

   public intgetAge() {

      return age;

   }

   public voidsetAge(intage){

      this.age = age;

   }

   public User(String name,intage){

      super();

      this.name = name;

      this.age = age;

   }

   @Override

   public String toString() {

      return "User [name=" + name + ", age="+ age+ "]";

   }

}

创建自定义比较器

public class MyCom implements Comparator<User>{

   public int compare(User o1,User o2) {

      int i=o1.getAge()-o2.getAge();

      return i;

   }

}

使用带泛型的TreeSet保存自定义对象

   public voidtest2(){

      TreeSet<User> t=new TreeSet<User>(new MyCom());

      t.add(newUser("看看",123));

      t.add(newUser("看看",13));

      t.add(newUser("看看",133));

      t.add(newUser("看看",12));

      System.out.println(t);

   }

三、       泛型类

如果定义一个类时，使用了泛型，这个类就是泛型类。

例子1：创建一个泛型类

public class Tool1<T> {

   //当使用这个类对象的时候，给什么类型，这个T就是什么类型。

   private T t;

   public voidadd(T t){

      this.t=t;

   }

   public T get(){

      return this.t;

   }

}

实例化这个类的时候给定泛型

   public voidtest3(){

      Tool1<String> t=new Tool1<String>();

      t.add("看看");

      //t.add(13);

      System.out.println(t.get().length());

   }

注意：不能在类的静态方法中使用泛型类的泛型，因为泛型类的泛型在实例化时确定，而静态方法的加载先于实例化。

例子2：创建一个带多个泛型的泛型类

创建泛型类

public class Tool2<T,X,Y> {

   //当使用这个类对象的时候，给什么类型，这个T就是什么类型。

   public voidshow(T t,X x,Y y){

      System.out.println(t);

      System.out.println(x);

      System.out.println(y);

   }

  

/* public static void show(T t){

      System.out.println(t);

   }

   不能在泛型类的静态方法中使用泛型类的泛型

   */

}

使用泛型类

   public voidtest4(){

      Tool2<Integer,String,Double> t=newTool2<Integer,String,Double>();

      t.show(1, "会话", 1.2);

   }

四、       方法泛型

创建类，设置方法泛型

public class Tool3{

   public<M> voidshow(M m){

      System.out.println(m);

   }

   //静态方法可以使用泛型中的方法

   public static<P> voidfunc(P p){

      System.out.println(p);

   }

}

使用泛型方法

   public voidtest5(){

      Tool3 t=new Tool3();

      t.show(14);

      Tool3.func("kk");

   }

五、       泛型接口

当一个类实现一个接口的时候，可以在实现这个接口的时候指定接口的具体类型，这个接口就是泛型接口。如果指定了具体的数据类型，这个实现类就不是一个泛型类。

创建一个类实现接口，指定这个接口的类型。如果一个类在实现一个泛型接口的时候，没有指定接口的具体类型，那么这个类本身也是一个泛型类。泛型的类型需要在实例化这个类的时候确定。如果一个类去实现或者继承一个接口，就会把泛型也继承下来，这称为泛型的传递。

实现接口时指定具体类型的例子：

public class MyCom2 implements Comparator<String>{

   public intcompare(String o1,String o2) {

      return 0;

   }

}

实例化泛型接口的实现类

   public voidtest6(){

      MyCom2 my=new MyCom2();

      System.out.println(my.toString());

   }

实现接口时不指定具体类型的例子：

public class MyCom3<T> implements Comparator<T>{

   public intcompare(T o1, T o2) {

      return 0;

   } 

}

实例化实现类的时候确定泛型的类型

   public voidtest61(){

      MyCom3<String> my=newMyCom3<String>();

      System.out.println(my.toString());

   }

六、       泛型的通配符

如果不清楚泛型的具体类型是什么的时候，可以使用通配符，写法是一个一个？。如<?>。

   public voidtest7(){

      List<User> l1=new ArrayList<User>();

      l1.add(newUser("hh",13));

      l1.add(newUser("h2h",153));

      l1.add(newUser("h4h",143));

      test(l1);

      List<String> l2=newArrayList<String>();

      l2.add("ll");

      l2.add("浏览");

      l2.add("看看");

      test(l2);

   }

   public void test(List<?> l){

      for(Iterator<?> i=l.iterator();i.hasNext();){

         System.out.println(i.next());

      }

   }

通配符的上限，使用关键字extends，只能接受extends后的类的或者这个类的子类。

通配符的下限，使用关键字super，只能接受super后面的类的或者这个类的父类。

通配符上下限的例子：

   public voidtest8(){

      List<sun> l1=new ArrayList<sun>();

      List<zi> l2=new ArrayList<zi>();

      List<fu> l3=new ArrayList<fu>();

      testExtends(l1);

      testSuper(l3);

      //testExtends(l3);

      //testSuper(l1);     

   }

   //通配符的上限

   public voidtestExtends(Collection<? extends zi> c){

     

   }

   //通配符的下限

   public voidtestSuper(Collection<? super zi> c){

     

   }

   class fu{}

   class zi extendsfu{}

   class sun extendszi{}