Java---泛型

基本介绍

泛型是Java中的一种机制，允许在定义类、接口和方法时使用类型参数，从而使代码可以处理多种数据类型，提高代码的重用性和安全性。

1）泛型又称参数化类型，是 jdk 5.0 出现的新特性，解决数据类型的安全性问题

2）在类声明或实例化时只要制定好需要的具体的类型即可

3）java 泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生 ClassCastException 异常。同时，代码更加简洁、健壮

4）泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型。

使用传统方法的问题分析

1）不能对加入到集合 ArrayList 中的数据类型进行约束（不安全）

2）遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响

泛型的好处

1）编译时，检查添加元素的类型，提高了安全性

2）减少了类型转换的次数，提高效率

不使用泛型

Dog -> Object ->Dog // 放入到 ArrayList 会先转成 Object，在取出时，还需要转换成 Dog

使用泛型

Dog ->Dog ->Dog // 放入时，和取出时，不需要类型转换，提高效率

3）不再提示编译警告

package com.heima.Hello.generic_;

import java.util.ArrayList;

@SuppressWarnings({"all"})
public class generic01 {
    public static void main(String[] args) {

        ArrayList<Dog> list = new ArrayList<Dog>();
        list.add(new Dog("大黄",10));
        list.add(new Dog("发财",6));
        list.add(new Dog("旺财",9));

        System.out.println("===使用泛型===");
        for (Dog dog : list) {
            System.out.println(dog.getName() + "-" + dog.getAge());
        }
    }
}

class Dog {
    private String name;
    private int age;
    public Dog(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;
    }
}

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

1. interface List<T> {}，public class HashSet<E>{}..等等

说明：T，E只能是引用类型

看看下面语句是否正确？：

List<Integer> list = new ArrayList<Integer>(); // OK

List<int> list2 = new ArrayList<int>(); // 错误

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

3. 泛型使用形式

List<Integer> list1 = new ArrayList<Integer>();

List<Integer> list2 = new ArrayList<>(); [说明：]

4. 如果我们这样写 List list3 = new ArrayList(); 默认给它的泛型是 [ <E> E 就是 Object ]

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

public class generic03 {
    public static void main(String[] args) {
        // 1. 给泛型指向数据类型是，要求是引用类型，不能说基本数据类型
        List<Integer> list_1 = new ArrayList<Integer>();
        // List<Integer> list2 = new ArrayList<Integer>();

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

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

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

        // 在实际开发中，我们往往简写
        // 编译器会进行类型推断，推荐使用如下写法
        ArrayList<Integer> list3 = new ArrayList<>();
        List<Integer> list4 = new ArrayList<>();

        // 后面的 new ArrayList<Pig>().var 会自动省略后面的。如下
        ArrayList<Pig> pigs = new ArrayList<>();


    }
}

class A{}
class B extends A{}

class Pig<E> {
    E e;
    public Pig(E e) {
        this.e = e;
    }

    public void f() {
        System.out.println(e.getClass()); // e的运行类型
    }
}

泛型课堂练习

定义 Employee 类

1）该类包含：private 成员变量 name，sal，birthday，其中 birthday 为 MyDate 类的对象；

2）为每一个属性定义 getter，setter 方法

3）重写 toString 方法输出 name，sal，birthday

4）MyDate 类包含：private 成员变量 month，day，year；并为每一个属性定义 getter，setter 方法

5）创建该类的 3 个对象，并把这些对象放入 ArrayList 集合中（ArrayList 需使用泛型来定义），对集合中的元素进行排序，并遍历输出；

排序方式：调用 ArrayList 的 sort 方法，传入 Comparator 对象 [ 使用泛型 ]，先按照 name 排序，如果 name 相同，则按生日日期的先后排序 [ 即：定制排序 ]

import org.jetbrains.annotations.NotNull;

import java.util.ArrayList;
import java.util.Comparator;

public class genericExercise {
    public static void main(String[] args) {
        /*
            定义 Employee 类
            1）该类包含：private 成员变量 name，sal，birthday，
            其中 birthday 为 MyDate 类的对象；
            2）为每一个属性定义 getter，setter 方法
            3）重写 toString 方法输出 name，sal，birthday
            4）MyDate 类包含：private 成员变量 month，day，year；
            并为每一个属性定义 getter，setter 方法
            5）创建该类的 3 个对象，并把这些对象放入 ArrayList 集合中
            （ArrayList 需使用泛型来定义），对集合中的元素进行排序，并遍历输出；
            排序方式：调用 ArrayList 的 sort 方法，
            传入 Comparator 对象 [ 使用泛型 ]，先按照 name 排序，如果 name 相同，则按生日日期的先后排序   [ 即：定制排序 ]
         */
        ArrayList<Employee> employees = new ArrayList();
        employees.add(new Employee("tommy",20000,new MyDate(2000,1,20)));
        employees.add(new Employee("tommy",15000,new MyDate(2018,9,17)));
        employees.add(new Employee("andy",10000,new MyDate(1998,5,28)));

        System.out.println("employees = " + employees);

        System.out.println("===== 对雇员进行排序 =====");
        // 比较 name
        employees.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee emp1, Employee emp2) {
                if ( !(emp1 instanceof Employee && emp2 instanceof Employee) ) {
                    return 0;
                }
                // 比较 name
                int i = emp1.getName().compareTo(emp2.getName());
                if (i != 0) {
                    return i;
                }
                // 对年月日的比较封装到 MyDate 中
                // 封装后将来可维护性和复用性，就大大增强
                return emp1.getName().compareTo(emp2.getName());
            }
        });

        System.out.println("employees = " + employees);
    }
}
class MyDate implements Comparable<MyDate> {

   private int year;
   private int month;
   private int day;
   public MyDate(int year, int month, int day) {
       this.year = year;
       this.month = month;
       this.day = day;
   }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    @Override
    public String toString() {
        return "MyDate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }

    @Override
    public int compareTo( MyDate o) { // 把对 year-month-day 的比较放在这


        // 如果 name 相同，就比较它的 birthday 的 year
        int yearMinus = year - o.getYear();
        if (yearMinus != 0) {
            return yearMinus;
        }
        // 如果 year 相同，就比较它的 month
        int monthMinus = month - o.getMonth();
        if (monthMinus != 0) {
            return monthMinus;
        }
        // 如果 year 和 month 相同，就比较他们的 day
        return day - o.getDay();
    }
}

class Employee {
    private String name;
    private double sal;
    private MyDate birthday;

    public Employee(String name, double sal, MyDate birthday) {
        this.name = name;
        this.sal = sal;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

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

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }

    public MyDate getBirthday() {
        return birthday;
    }

    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }

    // 重写 toString 方法

    @Override
    public String toString() {
        return "\nEmployee{" +
                "name='" + name + '\'' +
                ", sal=" + sal +
                ", birthday=" + birthday +
                '}';
    }
}

自定义泛型

基本语法

class 类名<T , R...> { // ...表示可以有多个成员

}

注意细节

1）普通成员可以使用泛型（属性、方法）

2）使用泛型的数组，不能初始化

3）静态方法中不能使用类的泛型

4）泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型）

5）如果在创建对象时，没有指定类型，默认为 Object

public class CustomGeneric_ {
    public static void main(String[] args) {
        Tiger <Double,String,Integer> g = new Tiger<>("john");
//        g.setR(10.9);
//        // g.setT("yy")  // 报错
//        System.out.println("g = " + g);
        Tiger g2 = new Tiger("james");
        g2.setT("YY");
        System.out.println("g2 = " + g2);
    }
}


// 解读
// 1. Tiger 后面有泛型，就把 Tiger 类叫做自定义泛型类
// 2. T,R,M 是泛型的标识符，一般是单个的大写字母
// 3. 泛型标识符可以有多个
// 4. 普通成员可以使用泛型（属性、方法）
// 5. 使用泛型的数组，不能初始化
// 6. 静态方法中不能使用类的泛型
class Tiger<R,M,T> {
    String name;
    R r;  // 属性使用泛型
    M m;
    T t;

    public Tiger(String name, R r, M m, T t) { // 构造器使用泛型
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }

    public String getName() {
        return name;
    }

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

    public M getM() {
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }

    public R getR() {
        return r;
    }

    public void setR(R r) {
        this.r = r;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    // 因为静态和类是相关的，在类加载时，对象还没创建
    // 所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化
//    static M t;
//    public static void f(M m) {
//
//    }

      @Override
    public String toString() {
        return "Tiger{" +
                "name='" + name + '\'' +
                ", r=" + r +
                ", m=" + m +
                ", t=" + t +
                '}';
    }
}

自定义泛型接口

基本语法

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

}

注意细节

1）接口中，静态成员不能使用泛型（这个和泛型类规定一样）

2）泛型接口的类型，在 继承接口 或者 实现接口 时确定

3）没有指定类型，默认为 Object

package com.heima.Hello.CustomGeneric;

public class InterfaceGeneric {
    public static void main(String[] args) {

    }
}

interface IA extends IUsb<String,Double> {

}

// 当我们去实现 IA 接口时，因为 IA 在继承 IUsb 接口时，指定了 U 为 String R为 Double
// 在实现 IUsb 接口的方法时，使用 String 替换 U，是 Double 替换 R

class AA implements IA {
    @Override
    public Double get(String s) {
        return 0.0;
    }

    @Override
    public void hi(Double aDouble) {

    }

}

// 没有指定类型，默认指定为 Object 类型
class CC implements IUsb { // 等价于 class CC implements IUsb<Object,Object>
// 建议这样写(更规范): class CC implements IUsb<Object,Object>

    @Override
    public Object get(Object o) {
        return null;
    }

    @Override
    public void hi(Object o) {

    }
}

interface IUsb<U,R> {
    int n = 10;
    // U name; 不能这样使用

    // 普通方法中，可以使用接口泛型
    R get(U u);

    void hi(R r);
}

自定义泛型方法

基本语法

修饰符 <T , R...> 返回类型 方法名 ( 参数列表 ) {

}

注意细节

1.泛型方法，可以定义在普通类中，也可以定义在泛型类中

public class CustomMethodGeneric {
    public static void main(String[] args) {

    }
}


// 泛型方法可以定义在类中，也可以定义在泛型类中
class Car {
    public void run() { // 普通的方法

    }

    //
    public <T,R> void fly(T t,R r) { // 泛型方法

    }
}

class Fish<U,V> { // 泛型类
    public void go() {

    }

    public <M,N> void swim(M m,N n){ // 泛型方法

    }

}

2.当泛型方法被调用时，类型会确定

public class CustomMethodGeneric {
    public static void main(String[] args) {
        Car car1 = new Car();
        car1.fly("宝马",350000); // 当调用方法时，传入参数，编译器就会确定类型
        car1.fly(20.1,10);
    }
}


// 泛型方法可以定义在类中，也可以定义在泛型类中
class Car {
    public void run() { // 普通的方法

    }

    //
    public <T,R> void fly(T t,R r) { // 泛型方法
        System.out.println(t.getClass());
        System.out.println(r.getClass());
    }
}

3.public void eat（E e）{} ，修饰符后没有 <T , R ...> eat 方法不是泛型方法，而是使用了泛型

package com.heima.Hello.CustomGeneric;

import java.util.ArrayList;

public class CustomMethodGeneric {
    public static void main(String[] args) {
       
        // 测试
        // T -> String , R ->ArrayList
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList(),11,3f);
    }
}




class Fish<U,V> { // 泛型类
    public void go() {

    }

    public <M,N> void swim(M m,N n){ // 泛型方法

    }

    // 1. 下面这个方法不是泛型方法
    // 2. 是 hi 方法使用了类声明的泛型

    public void hi(U u){

    }

    // 泛型方法，可以使用类声明的泛型，也可以使用自己声明的泛型
    public <K> void hello(K k,U u){
        System.out.println(k.getClass());
        System.out.println(u.getClass());

    }
}

泛型的继承和通配符说明

1）泛型不具有继承性

List<Object> list = new ArrayList<String>(); //

import java.util.ArrayList;

public class ExtendsGeneric_ {
    public static void main(String[] args) {
        Object str = new String("Hello World");

        // 泛型没有继承性
        // ArrayList<Object> list = new ArrayList<String>();
    }
}

2）<?>：支持任意泛型类型

package com.heima.Hello.CustomGeneric;
import java.util.ArrayList;
import java.util.List;

public class ExtendsGeneric_ {
    public static void main(String[] args) {
        
    public static void printCollection1(List<?> c){
        for(Object o : c){
            System.out.println(o);
        }
    }

}

3）<? extends A>：支持A类以及A类的子类，规定了泛型的上限

package com.heima.Hello.CustomGeneric;
import java.util.ArrayList;
import java.util.List;

public class ExtendsGeneric_ {
    public static void main(String[] args) {

        ArrayList<Object> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        List<AAA> list3 = new ArrayList<>();
        List<BBB> list4 = new ArrayList<>();
        List<CCC> list5 = new ArrayList<>();
        
//        printCollection2(list1); // ×
//        printCollection2(list2); // ×
//        printCollection2(list3); // √
//        printCollection2(list4); // √
//        printCollection2(list5); // √


    }
    
    public static void printCollection2(List<? extends AAA> c){
        for(Object o : c){
            System.out.println(o);
        }
    }
}

class AAA {}

class BBB extends AAA {}

class CCC extends BBB {}

4）<? super A>：支持A类以及A类的父类，不限于直接父类，规定了泛型的下限

package com.heima.Hello.CustomGeneric;
import java.util.ArrayList;
import java.util.List;

public class ExtendsGeneric_ {
    public static void main(String[] args) {

        ArrayList<Object> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        List<AAA> list3 = new ArrayList<>();
        List<BBB> list4 = new ArrayList<>();
        List<CCC> list5 = new ArrayList<>();

        
//        printCollection3(list1);  // √
//        printCollection3(list2);  // ×
//        printCollection3(list3);  // √
//        printCollection3(list4);  // ×
//        printCollection3(list5);  // ×

    }
    

    public static void printCollection3(List<? super AAA> c){
        for(Object o : c){
            System.out.println(o);
        }
    }

}

class AAA {}

class BBB extends AAA {}

class CCC extends BBB {}

Junit 的使用

如果是之前，就需要先创建对象，才能调用方法

public class Junit_ {
    public static void main(String[] args) {
        new Junit_().f1();
    }
    
    public void f1() {
        System.out.println("f1 方法被调用...");
    }
    public void f2() {
        System.out.println("f2 方法被调用...");
    }
}

但可以使用 Junit ，更方便

使用如下步骤

先写个 @test

按 alt + enter (个人试过，加上@Test 后，可选择导入包，直接就可以弹道效果)

可点运行

相关作业

1.编程题

定义一个泛型类 DAO<T>，在其中定义一个 Map 成员变量，Map 的键为 String 类型，值为 T 类型

分别创建以下方法：

（1）public void save(String id , T entity)：保存T类型的对象到 Map 成员变量中

（2）pulic T get(String id)：从 map 中获取 id 对应的对象

（3）public void update(String id , T entity)：替换 mao 中 key 为 id 的内容，改为 entity 对象

（4）public void delete(String id)：删除指定 id 对象

（5）public List<T> list() : 返回 map 中存放的所有 T 对象

定义一个 User 类：

该类包含：private 成员变量（int 类型）id ，age；（String 类型）name

创建 DAO 类的对象，分别调用其 save、get、update、list、delete 方法来操作 User 对象，使用Junit单元测试类进行测试

package com.heima.Hello.CustomGeneric;
import org.junit.Test;

import java.util.*;

public class Homework01 {
    public static void main(String[] args) {



        /**
         * 定义一个泛型类 DAO<T>，在其中定义一个 Map
         * 成员变量，Map 的键为 String 类型，值为 T 类型
         *
         * 分别创建以下方法：
         * （1）public void save(String id , T entity)：保存T类型的
         *  对象到 Map 成员变量中
         * （2）pulic T get(String id)：从 map 中获取 id 对应的对象
         * （3）public void update(String id , T entity)：
         *  替换 mao 中 key 为 id 的内容，改为 entity 对象
         * （4）public void delete(String id)：删除指定 id 对象
         *
         * 定义一个 User 类：
         * 该类包含：private 成员变量（int 类型）id ，age；（String 类型）name
         * 创建 DAO 类的对象，分别调用其 save、get、update、list、delete 方法来操作 User 对象，使用Junit单元测试类进行测试
         */
    }

    @Test
    public void testList() {
        // 这里给 DAO 指定的类型就是 User
        DAO<User> dao = new DAO<>();
        dao.save("001",new User(1,10,"jack"));
        dao.save("002",new User(2,18,"king"));
        dao.save("003",new User(3,22,"Mary"));

        List<User> list = dao.list();
        System.out.println("list = " + list);

        // 可以对数据进行修改 如下
        dao.update("003",new User(3,21,"Ivan"));
        System.out.println("=====修改后的 list=====");
        System.out.println("list = " + dao.list());

        // 对其中一个进行删除
        System.out.println("=====删除 001 =====");
        dao.delete("001");
        System.out.println("list = " + dao.list());

        // 使用 get 方法得到某一个
        System.out.println("===== get 003 =====");
        System.out.println("list = " + dao.get("003"));
    }
}

class DAO<T> {
    Map<String, T> map = new HashMap<>();

    public void save(String id,T entity){
        map.put(id, entity); // 存T类型的对象到 Map 成员变量中
    }

    public T get(String id){
        return map.get(id); // 从 map 中获取 id 对应的对象
    }

    public void update(String id,T entity){
        map.put(id, entity); // 替换 mao 中 key 为 id 的内容，改为 entity 对象
    }
    public void delete(String id){
        map.remove(id);     // 删除指定 id 对象
    }

    public List<T> list(){
        // 创建 ArrayList
        ArrayList<T> list = new ArrayList<>();

        // 遍历 map
        Set<String> keys = map.keySet();
        for(String key : keys){
            // map.get(key) 返回就是 User 对象 -> ArrayList
            list.add(map.get(key)); // 也可以使用本类的 get 方法
        }
        return list;
    }
}
//
//* 定义一个 User 类：
//        * 该类包含：private 成员变量（int 类型）id ，age；（String 类型）name
//         * 创建 DAO 类的对象，分别调用其 save、get、update、list、delete 方
//         法来操作 User 对象，使用Junit单元测试类进行测试
//         */
class User {
    private int id;
    private int age;
    private String name;

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}