java基础——泛型

泛型的引入

看下面这段代码：

1. private static int add(int a, int b) {
2.     System.out.println(a + "+" + b + "=" + (a + b));
3.     return a + b;
4. }
6. private static float add(float a, float b) {
7.     System.out.println(a + "+" + b + "=" + (a + b));
8.     return a + b;
9. }
11. private static double add(double a, double b) {
12.     System.out.println(a + "+" + b + "=" + (a + b));
13.     return a + b;
14. }

复制代码

如果没有泛型，要实现不同类型的加法，每种类型都需要重载一个add方法；通过泛型，我们可以复用为一个方法：

1. private static <T extends Number> double add(T a, T b) {
2.     System.out.println(a + "+" + b + "=" + (a.doubleValue() + b.doubleValue()));
3.     return a.doubleValue() + b.doubleValue();
4. }

复制代码

泛型中的类型在使用时指定，不需要强制类型转换（类型安全，编译器会检查类型）
下面这段代码：

1. List list = new ArrayList();
2. list.add("xxString");
3. list.add(100d);
4. list.add(new Person());

复制代码

我们在使用上述list中，list中的元素都是Object类型（无法约束其中的类型），所以在取出集合元素时需要人为的强制类型转化到具体的目标类型，且很容易出java.lang.ClassCastException`异常。
引入泛型，它将提供类型的约束，提供编译前的检查：

1. List<String> list = new ArrayList<String>();
3. // list中只能放String, 不能放其它类型的元素

复制代码

泛型的好处

1、编译时，检查添加元素的类型，提高了安全性
2、减少了类型转换的次数，提高效率
3、不再提示编译警告
介绍

1.泛型又称参数化类型，是Jdk5.0出现的新特性，解决数据类型的安全性问题
2.在类声明或实例化时只要指定好需要的具体的类型即可。
3.Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException.异常。同时，代码更加简洁、健壮
4.泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型。
代码举例：

1. public class Generic03 {
2.     public static void main(String[] args) {
3.         //注意，特别强调：E具体的数据类型在定义Person对象的时候指定，即在编译期间，就确定E是什么类型
4.         Person<String> person = new Person<>("dfdfs");
5.         person.show();//String
7.         /**
8.          * Person类相当于下面这样子
9.          * class Person{
10.          *     String s;//E表示s的数据类型，该数据类型在定义Person对象的时候指定，即在编译期间，就确定E是什么类型
11.          *
12.          *     public Person(String s) {//E也可以是参数类型
13.          *         this.s = s;
14.          *     }
15.          *
16.          *     public String f(){//返回类型使用E
17.          *         return s;
18.          *     }
19.          *     public void show(){
20.          *         System.out.println(s.getClass());//显示s的运行类型
21.          *     }
22.          * }
23.          */
25.         Person<Integer> person2 = new Person<>(100);
26.         person2.show();
28.         /**
29.          * Person类相当于下面这样子
30.          * class Person{
31.          *     Integer s;//E表示s的数据类型，该数据类型在定义Person对象的时候指定，即在编译期间，就确定E是什么类型
32.          *
33.          *     public Person(Integer s) {//E也可以是参数类型
34.          *         this.s = s;
35.          *     }
36.          *
37.          *     public Integer f(){//返回类型使用E
38.          *         return s;
39.          *     }
40.          *     public void show(){
41.          *         System.out.println(s.getClass());//显示s的运行类型
42.          *     }
43.          * }
44.          */
45.     }
46. }
47. //泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型
48. class Person<E>{
49.     E s;//E表示s的数据类型，该数据类型在定义Person对象的时候指定，即在编译期间，就确定E是什么类型
51.     public Person(E s) {//E也可以是参数类型
52.         this.s = s;
53.     }
55.     public E f(){//返回类型使用E
56.         return s;
57.     }
58.     public void show(){
59.         System.out.println(s.getClass());//显示s的运行类型
60.     }
61. }

复制代码

语法

泛型的声明

interface 接口名<T,R....>{

}和class 类名{}
说明：
1)其中，T,K,V不代表值，而是表示类型
2)任意字母都可以。常用T表示，是Type的缩写
泛型的实例化

要在类名后面指定类型参数的值（类型）。如：

1. List<String> strList = new ArrayList<String>();
2. Iterator<Customer> iterator = customers.iterator();

复制代码

泛型使用举例

需求：
​        1.创建3个学生对象
​        2.放入到HashSet中学生对象，使用.
​        3.放入到HashMap中，要求Key 是String name,Value就是学生对象
​        4.使用两种方式遍历

1. public class GenericExercise {
2.     public static void main(String[] args) {
3.         //使用泛型方式给HashSet放入3个学生对象
4.         HashSet<Student> students = new HashSet<>();
5.         students.add(new Student("jack",18));
6.         students.add(new Student("tom",18));
7.         students.add(new Student("ml",18));
9.         //第一种遍历方式，增强for循环
10.         for (Student student:students){
11.             System.out.println(student);
12.         }
14.         //使用泛型方式给HashMap放入3个学生对象
15.         HashMap<String, Student> hm = new HashMap<>();
16.         hm.put("milan",new Student("milan",34));
17.         hm.put("jack",new Student("jack",31));
18.         hm.put("tom",new Student("tom",30));
20.         //2.迭代器
21.         Set<Map.Entry<String, Student>> entries = hm.entrySet();
22.         Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
23.         System.out.println("==========================");
24.         while (iterator.hasNext()){
25.             Map.Entry<String, Student> next = iterator.next();
26.             System.out.println(next.getKey()+"-"+next.getValue());
28.         }
29.     }
30. }
31. class Student{
32.     private String name;
33.     private int age;
35.     public Student(String name, int age) {
36.         this.name = name;
37.         this.age = age;
38.     }
40.     public String getName() {
41.         return name;
42.     }
44.     public void setName(String name) {
45.         this.name = name;
46.     }
48.     public int getAge() {
49.         return age;
50.     }
52.     public void setAge(int age) {
53.         this.age = age;
54.     }
56.     @Override
57.     public String toString() {
58.         return "Student{" +
59.                 "name='" + name + '\'' +
60.                 ", age=" + age +
61.                 '}';
62.     }
63. }

复制代码

泛型使用注意事项

1.interface 接口名<T,R....>{

}和class 类名中T,K,V只能是引用类型。如下面：

1. List<Integer> list = new ArrayList<Integer>();//这样写正确
2. List<int> list = new ArrayList<int>();//这样写错误

复制代码

2.在给泛型指定具体类型后，可以传入该类型或者其子类类型
3.泛型使用形式

1. //1.第一种方式
2. List<Integer> list1 = new ArrayList<Integer>();
3. //2.第二种方式
4. List<Integer> Iist2 = new ArrayList<>();

复制代码

3.如果我们这样写List list3=new ArrayList();默认给它的泛型是  E就是Object.,等价于ArrayList arrayList = new ArrayList();
自定义泛型

自定义泛型类

语法：

1. class 类名<T,R....>{//......表示可以有多个泛型
2.         成员
3. }

复制代码

注意事项:
1.普通成员可以使用泛型（属性、方法）
2.使用泛型的数组，不能初始化
3.静态方法中不能使用类的泛型
4.泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型）
5.如果在创建对象时，没有指定类型，默认为Object

1. class Tiger<T,R,M>{
2.     String name;
3.     R r;//属性使用到泛型
4.     M m;
5.     T t;
6.     T[] ts;//因为数组在new时不能确定T的类型，就无法在内存开空间
8.     public Tiger(String name) {
9.         this.name = name;
10.     }
12.     public Tiger(R r, M m, T t) {
13.         this.r = r;
14.         this.m = m;
15.         this.t = t;
16.     }
18.     public Tiger(String name, R r, M m, T t) {//构造器使用泛型
19.         this.name = name;
20.         this.r = r;
21.         this.m = m;
22.         this.t = t;
23.     }
25.     //因为静态是和类相关的，在类加载时，对象还没有创建
26.     //所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化
27.     //static R r2;
28. //    public static void m1(M m){
29. //
30. //    }
32.     public R getR() {//返回类型可以使用泛型
33.         return r;
34.     }
36.     public void setR(R r) {//方法使用到泛型
37.         this.r = r;
38.     }
39. }

复制代码

自定义泛型接口

语法：

1. interface 接口名<T,R....>{
3. }

复制代码

注意事项：
1.接口中，静态成员也不能使用泛型（这个和泛型类规定一样）
2.泛型接口的类型，在继承接口或者实现接口时确定
3.没有指定类型，默认为Object

1. /**
2. * 泛型接口使用的说明
3. * 1.接口中，静态成员也不能使用泛型
4. * 2.泛型接口的类型，在继承接口或者实现接口时确定
5. * 3.没有指定类型，默认为Object
6. */
8. //在继承接口指定泛型接口的类型
9. interface IA extends IUsb<String,Double>{
11. }
12. //当我们去实现IA接口时，因为IA在继承IUsub接口时，指定了U为String, R为Double,在实现IUsub接口的方法时，使用String替换U,是Double替换R
13. class AA implements IA{
15.     @Override
16.     public Double get(String s) {
17.         return null;
18.     }
20.     @Override
21.     public void hi(Double aDouble) {
23.     }
25.     @Override
26.     public void run(Double r1, Double r2, String u1, String u2) {
28.     }
29. }
30. //实现接口时，直接指定泛型接口的类型
31. //给U指定Integer给R指定了Float
32. //所以，当我们实现IUsb方法时，会使用Integer替换U,使用Float替换R
33. class BB implements IUsb<Integer,Float>{
35.     @Override
36.     public Float get(Integer integer) {
37.         return null;
38.     }
40.     @Override
41.     public void hi(Float aFloat) {
43.     }
45.     @Override
46.     public void run(Float r1, Float r2, Integer u1, Integer u2) {
48.     }
49. }
50. //没有指定类型，默认为Object
51. //建议直接写成IUsb<Object,Object>
52. class CC implements IUsb{//等价class CC implements IUsb<Object,,Object>
53.     @Override
54.     public Object get(Object o) {
55.         return null;
56.     }
58.     @Override
59.     public void hi(Object o) {
61.     }
63.     @Override
64.     public void run(Object r1, Object r2, Object u1, Object u2) {
66.     }
68. }
69. interface IUsb<U,R>{
70.     //普通方法中，可以使用接口泛型
71.     R get(U u);
73.     void hi(R r);
75.     void run(R r1,R r2,U u1,U u2);
77.     //在jdk8中，可以在接口中，使用默认方法，也是可以使用泛型
78.     default R method(U u){
79.         return null;
80.     }
81. }

复制代码

自定义泛型方法

语法

1. 修饰符 <T,R...>返回类型 方法名（参数列表）{
3. }

复制代码

注意事项：
1.泛型方法，可以定义在普通类中，也可以定义在泛型类中
2.当泛型方法被调用时，类型会确定
3.public void eat(E e){},修饰符后设有eat方法不是泛型方法，而是使用了泛型

1. public class CustomMethodGeneric {
2.     public static void main(String[] args) {
3.         Car car = new Car();
4.         car.fly("宝马",100);//当调用方法时，传入参数，编译器，就会确定类型
5.         System.out.println("==================");
8.         Fish<String, ArrayList> fish = new Fish<>();
9.         fish.hello(new ArrayList(),11.3f);
10.     }
11. }
12. //泛型方法，可以定义在普通类中，也可以定义在泛型类中
13. class Car{//普通类
14.     public void run(){//普通方法
16.     }
18.     //泛型方法
19.     //1.<T,R>就是泛型
20.     //2.是提供给 fly使用的
21.     public <T,R> void fly(T t,R r){//泛型方法
22.         System.out.println(t.getClass());
23.         System.out.println(r.getClass());
24.     }
25. }
26. class Fish<T,R>{//泛型类
28.     public <U,M> void eat(U u,M m){//泛型方法
30.     }
32.     //下面的这个hi方法不是泛型方法，是hi方法使用了类声明的泛型
33.     public void hi(T t){
35.     }
37.     //泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
38.     public <K> void hello(R r,K k){
39.         System.out.println(r.getClass());
40.         System.out.println(k.getClass());
41.     }
42. }

复制代码

泛型的继承和通配符

说明：
1.泛型不具备继承性
2.:支持任意泛型类型

3.