Java泛型学习

Posted 2020-09-21 JMCui

1、泛型的概念

    泛型即“参数化类型”，就比如我们定义方法的时候，定义一个变量，称为形参，变量值根据传进去的实参的值不同而改变。而泛型的出现，就是为了解决类型也能根据传进去的类型改变的问题，所以称为参数化类型，也就是说所操作的数据类型被指定为一个参数。主要用在定义方法、类、集合上，可以很好的减少代码的重复。

 

2、泛型中的标识符含义

 E - Element (在集合中使用，因为集合中存放的是元素)

 T - Type（Java 类）

 K - Key（键）

 V - Value（值）

 N - Number（数值类型）

？ -  表示不确定的java类型

 S、U、V  - 2nd、3rd、4th types

3、定义一个泛型方法

    首先，泛型的声明，必须在方法的修饰符（public,static,final,abstract等）之后，返回值声明之前。然后，和泛型类一样，可以声明多个泛型，用逗号隔开

 1 import java.util.ArrayList;
 2 import java.util.List;
 3 
 4 /**
 5  * Created by Administrator on 2017/6/5.
 6  * <p>
 7  * Description:
 8  */
 9 public class One
10 {
11     public static void main(String[] args)
12     {
13         List<Integer> integers=new ArrayList<>();
14         integers.add(111);
15         integers.add(222);
16 
17         List<String> list=new ArrayList<>();
18         list.add("111");
19         list.add("222");
20 
21         System.out.println(print(integers,list));
22 
23     }
24 
25     public static <T1,T2> T1 print(List<T1> list,List<T2> list2){
26         T1 t1 = list.get(0);
27         return t1;
28     }
29 }

 

4、定义一个泛型类

 1 /**
 2  * Created by Administrator on 2017/6/5.
 3  * <p>
 4  * Description:
 5  */
 6 public class Box<T>//这里可以定义多个泛型，用逗号分割
 7 {
 8     private String name;
 9     private T t;
10 
11     public Box()
12     {
13 
14     }
15 
16     public Box(T t, String name)
17     {
18         this.t = t;
19         this.name = name;
20     }
21 
22     public String getName()
23     {
24         return name;
25     }
26 
27     public void setName(String name)
28     {
29         this.name = name;
30     }
31 
32     public T getT()
33     {
34         return t;
35     }
36 
37     public void setT(T t)
38     {
39         this.t = t;
40     }
41 }

 1 /**
 2  * Created by Administrator on 2017/6/5.
 3  * <p>
 4  * Description:
 5  */
 6 public class Two
 7 {
 8     public static void main(String[] args)
 9     {
10         Box<String> box=new Box<>("stirng","小明");
11         String t = box.getT();
12         System.out.println(t);
13 
14         Box<Integer> box1=new Box<>(123456,"小红");
15         Integer t1 = box1.getT();
16         System.out.println(t1);
17     }
18 }

 

5、泛型类的继承

父类：

 1 package fan;
 2 
 3 /**
 4  * Created by Administrator on 2017/6/5.
 5  * <p>
 6  * Description:
 7  */
 8 public class Person<T>
 9 {
10     private String code;
11     private String name;
12     private T t;
13 
14     public String getCode()
15     {
16         return code;
17     }
18 
19     public void setCode(String code)
20     {
21         this.code = code;
22     }
23 
24     public String getName()
25     {
26         return name;
27     }
28 
29     public void setName(String name)
30     {
31         this.name = name;
32     }
33 
34     public T getT()
35     {
36         return t;
37     }
38 
39     public void setT(T t)
40     {
41         this.t = t;
42     }
43 
44     @Override
45     public String toString()
46     {
47         return "Person{" + "code=‘" + code + ‘\‘‘ + ", name=‘" + name + ‘\‘‘ + ", t=" + t + ‘}‘;
48     }
49 }

 

两个子类

 1 package fan;
 2 
 3 /**
 4  * Created by Administrator on 2017/6/5.
 5  * <p>
 6  * Description:
 7  */
 8 public class Student extends Person<Integer>
 9 {
10 }

package fan;

/**
 * Created by Administrator on 2017/6/5.
 * <p>
 * Description:
 */
public class Teacher extends Person<String>
{

}

 

泛型辅助类

 1 package fan;
 2 
 3 /**
 4  * Created by Administrator on 2017/6/5.
 5  * <p>
 6  * Description:
 7  */
 8 public class BuildHelper<T extends Person>//这里的意思是对泛型进行限制，输入的泛型只能是继承Person类的
 9 {
10     private Class<T> clazz;
11 
12     public BuildHelper(){
13 
14     }
15     //构造器，仅限自己调用
16     private BuildHelper(Class<T> clazz){
17         this.clazz=clazz;
18     }
19 
20     public static <T extends Person> BuildHelper<T> with(Class<T> clazz){
21         return new BuildHelper<T>(clazz);
22     }
23 
24     //返回泛型类
25     public T build(){
26         try {
27             T t = clazz.newInstance();
28             return t;
29         } catch (InstantiationException e) {
30             e.printStackTrace();
31         } catch (IllegalAccessException e) {
32             e.printStackTrace();
33         }
34         return null;
35     }
36 }

测试

 1 package fan;
 2 
 3 /**
 4  * Created by Administrator on 2017/6/5.
 5  * <p>
 6  * Description:
 7  */
 8 public class Main
 9 {
10     public static void main(String[] args)
11     {
12         BuildHelper<Student> studentBuildHelper = BuildHelper.with(Student.class);
13         Student student = studentBuildHelper.build();
14         student.setT(123);
15         student.setCode("123");
16         student.setName("123");
17 
18         BuildHelper<Teacher> teacherBuildHelper = BuildHelper.with(Teacher.class);
19         Teacher teacher = teacherBuildHelper.build();
20         teacher.setT("1234");
21         teacher.setCode("1234");
22         teacher.setName("1234");
23 
24         System.out.println(student);
25         System.out.println(teacher);
26     }
27 }