泛型简介，泛型类及使用

若是咱们须要产生多个对象，每一个对象的逻辑彻底同样，只是对象内的成员变量的类型不一样。那么咱们该如何去作？

①   建立多个类文件，给每一个类中的成员变量设置指定的数据类型;

 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