泛型簡介，泛型類及使用

如果我們需要產生多個對象，每個對象的邏輯完全一樣，只是對象內的成員變量的類型不同。那么我們該如何去做？

①   創建多個類文件，給每個類中的成員變量設置指定的數據類型;

public class Demo1{  2     public static void main(String []args){  3         MyClass1 myclass1=new MyClass1("張三");  4  System.out.println(myclass1.getData());  5         MyClass2 myclass2=new MyClass2(10);  6  System.out.println(myclass2.getData());  7  }  8 }  9 
class MyClass1{ 11     private String data; 12     public MyClass1(String data){ 13         this.data=data; 14  } 15     
    public void setData(String data){ 17         this.data=data; 18  } 19     public String getData(){ 20         return data; 21  } 22 } 23 
class MyClass2{ 25     private int data; 26     public MyClass2(int data){ 27         this.data=data; 28  } 29     
    public void setData(int data){ 31         this.data=data; 32  } 33     public int getData(){ 34         return data; 35  } 36 }

缺點：這種方式會導致類的膨脹，重用性太差;

①   創建一個類文件，給這個類中的成員變量設置Object數據類型;

public class Demo11{  2     public static void main(String []args){  3         MyClass myClass1=new MyClass("張三");  4  System.out.println((String)myClass1.getData());  5         MyClass myClass2=new MyClass(10);  6  System.out.println((Integer)myClass2.getData());  7         //以上可以執行  8         //但int類型不能裝換為String類型
 System.out.println((String)myClass2.getData()); 10  } 11 } 12 
class MyClass{ 14     private Object data; 15     public MyClass(Object data){ 16         this.data=data; 17  } 18     
    public void setData(Object data){ 20         this.data=data; 21  } 22     public Object getData(){ 23         return data; 24  } 25 }

缺點：編譯時正常，但運行時可能會異常;

 

泛型類就能解決以上兩個問題;

泛型簡介

①   泛型是JDK4.5引入的新特性，也是最重要的一個特性;

②   泛型可以再編譯的時候檢查類型安全，並且所有的強制轉換都是自動和隱式的;

③   泛型的原理就是“類型的參數化”，即把類型看作參數。也就是說把所要操作的數據類型看作參數，就像方法的形式參數是運行時傳遞的值的占位符一樣;

④   簡單的說，類型變量扮演的角色就如同一個參數，它提供給編譯器用來類型檢查的信息;

⑤   泛型可以提高代碼的擴展性和重用性;

總結：所謂泛型，即通過參數化類型來實現在同一份代碼上操作多種數據類型，泛型編程是一種編程范式，它利用“參數化類型”將類型抽象化，從而實現更為靈活的復用;

泛型類示例：

public class GenClass <T>{  2     private T obj;  3     public GenClass(T obj){  4     this.obj=obj;  5 }  6 public T getObj(){  7     return obj;  8 }  9 public void setObj(T obj){ 10     this.obj=obj; 11 } 12 }

T代表類型，比如Integer，String

用泛型類解決以上問題

public class GenericDemo1{  2     public static void main(String []args){  3         //創建一個泛型類對象
        GenClass<String> gen1=new GenClass<String>("張三");  5  System.out.println(gen1.getData());  6         GenClass<Integer> gen2=new GenClass<Integer>(10);  7  System.out.println(gen2.getData());  8         //使用了泛型之后再做強制類型轉換編譯無法通過  9         //System.out.println((String)gen2.getData());
 } 11 } 12 
//創建一個泛型類
class GenClass<T>{ 15     private T data; 16     public GenClass(T data){ 17         this.data=data; 18  } 19     
    public void setData(T data){ 21         this.data=data; 22  } 23     public T getData(){ 24         return data; 25  } 26 }

泛型的用法

① 泛型的參數類型可以使泛型類;

public class GenericDemo1{  2     public static void main(String []args){  3         //一個泛型類作為另一個泛型類的參數
        GenClass<GenClass<Student>> gen1=new GenClass<GenClass<Student>>();  5         GenClass<Student> gen2=new GenClass<Student>();  6         gen2.setData(new Student("張三"));  7  gen1.setData(gen2);  8         
 System.out.println(gen1.getData().getData()); 10  } 11 } 12 
//創建一個泛型類
class GenClass<T>{ 15     private T data; 16     public GenClass(){ 17         
 } 19     public GenClass(T data){ 20         this.data=data; 21  } 22     
    public void setData(T data){ 24         this.data=data; 25  } 26     public T getData(){ 27         return data; 28  } 29 } 30 
class Student{ 32     private String name; 33     public Student(String name){ 34         this.name=name; 35  } 36     public String toString(){ 37         return "我是："+name; 38  } 39 }

② 泛型類可以同時設置多個類型參數;

public class GenericDemo1{  2     public static void main(String []args){  3         //帶2個參數的泛型
        GenClass2<String,Integer> gen1=new GenClass2<String,Integer>("張三",20);  5  System.out.println(gen1.getData1());  6  System.out.println(gen1.getData2());  7  }  8 }  9 
class GenClass2<T1,T2>{ 11     private T1 data1; 12     private T2 data2; 13     public GenClass2(T1 data1,T2 data2){ 14         this.data1=data1; 15         this.data2=data2; 16  } 17     public T1 getData1(){ 18         return data1; 19  } 20     public T2 getData2(){ 21         return data2; 22  } 23 }

③ 泛型類可以繼承泛型類;

public class GenericDemo2{  2     public static void main(String []args){  3         //一個泛型類繼承另一個泛型類
        SubClass<String,Integer> sub=new SubClass<String,Integer>("張三",20);  5  System.out.println(sub.show1());  6  }  7 }  8 
class SuperClass<T1>{ 10     private T1 var1; 11     public SuperClass(T1 var1){ 12         this.var1=var1; 13  } 14     
    public T1 show1(){ 16         return var1; 17  } 18 } 19 
class SubClass<T1,T2> extends SuperClass<T1>{ 21     private T2 var2; 22     public SubClass(T1 var1,T2 var2){ 23         super(var1); 24         this.var2=var2; 25  } 26     //重寫父類的方法
    public T1 show1(){ 28         return super.show1(); 29  } 30 }

④泛型類可以實現泛型接口;

public class GenericDemo2{  2     public static void main(String []args){  3         //一個泛型類繼承另一個泛型類
        SubClass<String,Integer> sub=new SubClass<String,Integer>("張三",20);  5  System.out.println(sub.show1());  6         //實現接口的方法
        sub.show2(100);  8  }  9 } 10 
class SuperClass<T1>{ 12     private T1 var1; 13     public SuperClass(T1 var1){ 14         this.var1=var1; 15  } 16     
    public T1 show1(){ 18         return var1; 19  } 20 } 21 
interface IInfo<T2>{ 23     public void show2(T2 var3); 24 } 25 
class SubClass<T1,T2> extends SuperClass<T1> implements IInfo<T2>{ 27     private T2 var2; 28     public SubClass(T1 var1,T2 var2){ 29         super(var1); 30         this.var2=var2; 31  } 32     //重寫父類的方法
    public T1 show1(){ 34         return super.show1(); 35  } 36     //實現接口的方法
    public void show2(T2 var3){ 38  System.out.println(var3); 39  System.out.println(var2); 40         //雖然都是Integer類型，但泛型會先將其轉為Object類型，所以不能相加 41         //System.out.println(var2+var3);
 } 43 }