泛型簡介，泛型類及使用

若是咱們須要產生多個對象，每一個對象的邏輯徹底同樣，只是對象內的成員變量的類型不一樣。那麼咱們該如何去作？

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

 1 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 
10 class MyClass1{ 11     private String data; 12     public MyClass1(String data){ 13         this.data=data; 14  } 15     
16     public void setData(String data){ 17         this.data=data; 18  } 19     public String getData(){ 20         return data; 21  } 22 } 23 
24 class MyClass2{ 25     private int data; 26     public MyClass2(int data){ 27         this.data=data; 28  } 29     
30     public void setData(int data){ 31         this.data=data; 32  } 33     public int getData(){ 34         return data; 35  } 36 }

View Code

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

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

 1 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類型
 9  System.out.println((String)myClass2.getData()); 10  } 11 } 12 
13 class MyClass{ 14     private Object data; 15     public MyClass(Object data){ 16         this.data=data; 17  } 18     
19     public void setData(Object data){ 20         this.data=data; 21  } 22     public Object getData(){ 23         return data; 24  } 25 }

View Code

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

 

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

泛型簡介

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

②   泛型能夠再編譯的時候檢查類型安全，而且全部的強制轉換都是自動和隱式的;

③   泛型的原理就是「類型的參數化」，即把類型看做參數。也就是說把所要操做的數據類型看做參數，就像方法的形式參數是運行時傳遞的值的佔位符同樣;

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

⑤   泛型能夠提升代碼的擴展性和重用性;

總結：所謂泛型，即經過參數化類型來實如今同一份代碼上操做多種數據類型，泛型編程是一種編程範式，它利用「參數化類型」將類型抽象化，從而實現更爲靈活的複用;

泛型類示例：

 1 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

用泛型類解決以上問題

 1 public class GenericDemo1{  2     public static void main(String []args){  3         //建立一個泛型類對象
 4         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());
10  } 11 } 12 
13 //建立一個泛型類
14 class GenClass<T>{ 15     private T data; 16     public GenClass(T data){ 17         this.data=data; 18  } 19     
20     public void setData(T data){ 21         this.data=data; 22  } 23     public T getData(){ 24         return data; 25  } 26 }

View Code

泛型的用法

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

 1 public class GenericDemo1{  2     public static void main(String []args){  3         //一個泛型類做爲另外一個泛型類的參數
 4         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         
 9  System.out.println(gen1.getData().getData()); 10  } 11 } 12 
13 //建立一個泛型類
14 class GenClass<T>{ 15     private T data; 16     public GenClass(){ 17         
18  } 19     public GenClass(T data){ 20         this.data=data; 21  } 22     
23     public void setData(T data){ 24         this.data=data; 25  } 26     public T getData(){ 27         return data; 28  } 29 } 30 
31 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 }

View Code

② 泛型類能夠同時設置多個類型參數;

 1 public class GenericDemo1{  2     public static void main(String []args){  3         //帶2個參數的泛型
 4         GenClass2<String,Integer> gen1=new GenClass2<String,Integer>("張三",20);  5  System.out.println(gen1.getData1());  6  System.out.println(gen1.getData2());  7  }  8 }  9 
10 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 }

View Code

③ 泛型類能夠繼承泛型類;

 1 public class GenericDemo2{  2     public static void main(String []args){  3         //一個泛型類繼承另外一個泛型類
 4         SubClass<String,Integer> sub=new SubClass<String,Integer>("張三",20);  5  System.out.println(sub.show1());  6  }  7 }  8 
 9 class SuperClass<T1>{ 10     private T1 var1; 11     public SuperClass(T1 var1){ 12         this.var1=var1; 13  } 14     
15     public T1 show1(){ 16         return var1; 17  } 18 } 19 
20 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     //重寫父類的方法
27     public T1 show1(){ 28         return super.show1(); 29  } 30 }

View Code

④泛型類能夠實現泛型接口;

 1 public class GenericDemo2{  2     public static void main(String []args){  3         //一個泛型類繼承另外一個泛型類
 4         SubClass<String,Integer> sub=new SubClass<String,Integer>("張三",20);  5  System.out.println(sub.show1());  6         //實現接口的方法
 7         sub.show2(100);  8  }  9 } 10 
11 class SuperClass<T1>{ 12     private T1 var1; 13     public SuperClass(T1 var1){ 14         this.var1=var1; 15  } 16     
17     public T1 show1(){ 18         return var1; 19  } 20 } 21 
22 interface IInfo<T2>{ 23     public void show2(T2 var3); 24 } 25 
26 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     //重寫父類的方法
33     public T1 show1(){ 34         return super.show1(); 35  } 36     //實現接口的方法
37     public void show2(T2 var3){ 38  System.out.println(var3); 39  System.out.println(var2); 40         //雖然都是Integer類型，但泛型會先將其轉爲Object類型，因此不能相加 41         //System.out.println(var2+var3);
42  } 43 }

View Code