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 }