泛型

       泛型，何为泛型？

       泛型：通过“参数化类型”来实现在同一份代码上操作多种数据类型。利用“参数化类型”将类型抽象化，从而实现灵活的复用。

       泛型的分类，泛型分为泛型类，与泛型方法，泛型接口。

       泛型类：

   public static void main(String[] args) {
        int obj = 345;
        GenericityEntity genericityEntity=new GenericityEntity<Integer>(obj);
        System.out.println("int:" + genericityEntity.getObj());
        String obj2 = "hello world";
        GenericityEntity genericityEntity2=new GenericityEntity<String>(obj2);
        System.out.println("String:" + genericityEntity2.getObj());
    }

public class GenericityEntity<T> {
    private T obj;
    public GenericityEntity(T obj) {
        this.obj=obj;
    }
    public T getObj() {
        return obj;
    }
    public void setObj(T obj) {
        this.obj = obj;
    }
}

泛型接口：

// 泛型接口的定义  
interface DemoInterface<T1, T2>  
{  
   T2 doSomeOperation(T1 t);  
   T1 doReverseOperation(T2 t);  
}  
   
//实现泛型接口的类  
class DemoClass implements DemoInterface<String, Integer>  
{  
   public Integer doSomeOperation(String t)  
   {  
      //其他代码  
   }  
   public String doReverseOperation(Integer t)  
   {  
      //其他代码  
   }  
}  

泛型方法：

public class TestMethod {
    public static void main(String[] args) {
        test("a"); //T -->String
    }
    //定义泛型方法
    public static <T> void test(T a){       
        System.out.println(a);
    }
    // extends表示上限<=   ...表示可变参数，例如将其换成[]就成了数组
    public static <T extends Closeable> void test(T... a){
        for(T temp:a){
            try {
               if(null!=temp){  temp.close();}
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

擦除泛型：

public class Student<T> {
        private T age;
        //private static T test; //泛型不能使用在静态属性上
        public Student() {
        }
        public Student(T age) {
            this.age = age;
        }
        public T getAge() {
            return age;
        }
        public void setAge(T age) {
            this.age = age;
        }
}
    /**
     * 泛型的擦除: 使用时 
     * 类似于 Object ,不等同于 Object
     */
    public static void main(String[] args) {
        //擦除 -->没有指定 泛型的具体类型
        Student student =new Student();
        student.setAge(100); //100 -->int -->Integer -->Object
        Object obj=student.getAge();
        System.out.println(obj);
        test(student);//编译不会类型检查，此处不会报错，因为Object类型相当于被擦除了
        Student<Object> student2 =new Student<Object>();
        //不等于 Object
       // test(student2); //会报错，因为这个地方已经申明了Object类型，就只能是Object类型
    }
    public static void test(Student<Integer> stu){
       ...................
       ...................
    }

注意：

public class ErasedTypeEquivalence { 
      public static void main(String[] args) { 
          //我们分别定义了一个接受String类型的List和一个接受Integer类型的List，
          //按照我们正常的理解，泛型ArrayList<T>虽然是相同的，但是我们给它传了不同的类型参数，
          //那么c1和2的类型应该是不同的。但是结果恰恰相反，运行程序发现二者的类型时相同的。这是为什么呢？
          //这里就要说到Java语言实现泛型所独有的——擦除
            Class c1 = new ArrayList<String>().getClass(); 
            Class c2 = new ArrayList<Integer>().getClass(); 
       System.out.println(c1 == c2); 
      } 
 }

擦除例子： http://blog.csdn.net/quniMdejiangyou/article/details/77963440?locationNum=2&fps=1