泛型简介，泛型类及使用

Posted 2020-07-01 泊而至远

如果我们需要产生多个对象，每个对象的逻辑完全一样，只是对象内的成员变量的类型不同。那么我们该如何去做？

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

 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