非零基础自学Java (老师：韩顺平) 第15章 泛型 15.3 泛型介绍 && 15.4 泛型的语法

非零基础自学Java (老师：韩顺平)

✈【【零基础 快速学Java】韩顺平 零基础30天学会Java】

第15章 泛型

15.3 泛型介绍

泛( 广泛 )型 (类型)

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

【举个栗子】

package com.dingjiaxiong.generic;

/**
 * ClassName: Generic03
 * date: 2022/9/6 10:42
 *
 * @author DingJiaxiong
 */

public class Generic03 {
    public static void main(String[] args) {
//        特别强调： E 具体的数据类型在定义 Person 对象的时候指定,即在编译期间，就确定 E 是什么类型
        Person<String> person = new Person<String>("韩老师666");
        person.show();

        Person<Integer> person2 = new Person<Integer>(100);
        person2.show();

    }
}

//泛型的作用：可以在类声明时通过一个标识 表示类 中某个属性的类型 【或者】 是某个方法的返回值类型 【或者】 参数类型
class Person<E>{
    E s;  //E 表示 s的数据类型，在定义Person对象的时候指定，即编译期间

    public Person(E s) { //E 也可以是参数类型
        this.s = s;
    }

    public E f(){ //返回类型使用 E
        return s;
    }

    public void show(){
        System.out.println(s.getClass()); //显示s的运行类型
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

运行结果

15.4 泛型的语法

15.4.1 泛型的声明

interface 接口{} 和 class 类{}
1

说明

• 其中 T、K、V代表值，而是表示类型
• 任意字母都可以，常用T，Type 的缩写

15.4.2 泛型的实例化

【在类名后面指定类型 参数的值(类型)】

比如：

List strList = new ArrayList();

Iterator iterator = customers.iterator;
1
2
3

15.4.3 泛型使用举例

【举个栗子】

package com.dingjiaxiong.generic;

import java.util.*;

/**
 * ClassName: GenericExercise
 * date: 2022/9/6 10:52
 *
 * @author DingJiaxiong
 */

@SuppressWarnings({"all"})
public class GenericExercise {
    public static void main(String[] args) {
        //使用泛型方式给HashSet 放入 3 个学生对象
        HashSet<Student> students = new HashSet<Student>();

        students.add(new Student("jack",18));
        students.add(new Student("tom",28));
        students.add(new Student("mary",19));

        //遍历
        for (Student student : students){
            System.out.println(student);
        }

        //使用泛型方式给HashMap 放入 3 个学生对象
        HashMap<String , Student> hashMap = new HashMap<String , Student>();

        hashMap.put("milan",new Student("milan",38));
        hashMap.put("smith",new Student("smith",48));
        hashMap.put("djx",new Student("dingjiaxiong",22));

        //迭代器EntrySet
        Set<Map.Entry<String , Student>> entries = hashMap.entrySet();

        Iterator<Map.Entry<String , Student>> iterator = entries.iterator();
        System.out.println("=================================================");
        while (iterator.hasNext()){
            Map.Entry<String , Student> next = iterator.next();
            System.out.println(next.getKey() + "-" + next.getValue());
        }
    }
}

class Student{
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

运行结果

15.4.4 泛型使用的注意事项和细节

1. interface List{} , public class HashSet{}..

T，E 只能是 引用类型
1
2
3

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

3. 泛型使用形式

   List list1 = new ArrayList();
   
   List list2 = new ArrayList<>();
   1
   2
   3

4. 如果这样写

   List list3 = new ArrayList();
   1

   那么默认给它的泛型是[ E 就是 Object ]

【举个栗子】

package com.dingjiaxiong.generic;

import java.util.ArrayList;
import java.util.List;

/**
 * ClassName: GenericDetail
 * date: 2022/9/6 11:04
 *
 * @author DingJiaxiong
 */

@SuppressWarnings({"all"})
public class GenericDetail {
    public static void main(String[] args) {
        //给泛型指定 数据类型 时，要求是 引用类型，不能是基本数据类型
        List<Integer> list = new ArrayList<Integer>(); //正确
//        List list2 = new ArrayList(); //直接报红

        //因为E 指定了A类型，构造器就传入new A()
        //在给泛型指定了具体类型后， 可以传入该类型 或者 其子类 类型
        Pig<A> aPig = new Pig<A>(new A());
        aPig.f();

        Pig<A> aPig2 = new Pig<A>(new B());
        aPig2.f();

        //泛型的使用形式
        ArrayList<Integer> list1 = new ArrayList<Integer>();
        List<Integer> list2 = new ArrayList<Integer>();

        //在开发中，往往简写，编译器会进行类型 推断
        ArrayList<Integer> list3 = new ArrayList<>();
        List<Integer> list4 = new ArrayList<>();
        ArrayList<Pig> pigs = new ArrayList<>();

        //如果像下面那样写
        //泛型默认是 Object
        ArrayList arrayList =  new ArrayList();
        //上面这个就等价于
//        ArrayList