JavaSE(14)_泛型

最新推荐文章于 2023-09-25 19:39:09 发布

自律彭于晏

最新推荐文章于 2023-09-25 19:39:09 发布

阅读量74

点赞数

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/zjr_java/article/details/125733334

版权

JavaSE 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

泛型出现的背景

泛型是一种标签,比如药店里面每个药柜都会贴着标签,里面装着什么要,或者说这里只能放什么药,不能放别的。因此在泛型常用在集合当中，规定集合里面只能放什么类型的数据，放其他类型的数据会出现编译错误
集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，此时把元素的类型设计成一个参数，这个类型参数叫做泛型。
Collection<E>，List<E>，ArrayList<E>这个<E>就是类型参数，即泛型。一旦创建集合对象的时候通过泛型设定了类型,类里面的参数带有E的都代表该类型，在调用对象属性和方法时如果不遵循类型就会编译异常。
所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）。
从JDK1.5以后，Java引入了“参数化类型（Parameterizedtype）”的概念，允许我们在创建集合时再指定集合元素的类型，正如：List，这表明该List只能保存字符串类型的对象。
JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。
泛型能够解决的问题：
- 解决元素存储的安全性问题，好比商品、药品标签，不会弄错
- 解决获取数据元素时，需要类型强制转换的问题，好比不用每回拿商品、药品都要辨别
- Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮。
- 注意：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换
在集合中使用泛型
1. 集合接口或集合类在jdk5.0时都修改为带泛型的结构
```
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
```
2. 在实例化集合类时，可以指明具体的泛型类型
```
ArrayList<Integer> list = new ArrayList();


-->


public class ArrayList<Integer> extends AbstractList<Integer>
        implements List<Integer>, RandomAccess, Cloneable, java.io.Serializable
```
3. 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型。
```
public boolean add(E e)


-->


public boolean add(Integer e)
```
4. 如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型。
代码演示泛型好处

package javase14;

import org.junit.Test;

import java.util.*;

public class genericity1 {
    //在集合中使用泛型之前的情况：
    @Test
    public void test(){
        ArrayList list = new ArrayList();
        //需求：Jdk1.7千使用add(Object obj)方法,存放学生的成绩
        list.add(78);
        list.add(49);
        list.add(72);
        list.add(81);
        list.add(89);
        //问题一：类型不安全,混入了一个String类型的数据
        list.add("Tom");

        for(Object score : list){
            //问题二：如果混入其他类型的数据,强转时可能出现类型转化异常
            int stuScore = (Integer)score;//例如list集合存放Integer类型数据且存放一个String,再遍历时强化转成Integer时会出现异常ClassCastException
            System.out.println(stuScore);
        }
    }

    //在集合中使用泛型的情况：以ArrayList为例
    @Test
    public void test2() {
        ArrayList<Integer> list = new ArrayList<>();

        list.add(78);
        list.add(49);
        list.add(72);
        list.add(81);
        list.add(89);
        //编译时，就会进行类型检查，保证数据的安全
//        list.add("Tom");//编译报错

        //因此避免了类型错误的强转操作,使得代码不用try catch因而更加简洁
        //迭代方式一
        for (Integer score : list) {
            int stuScore = score;
            System.out.println(stuScore);
        }
        //迭代方式二
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

        /*
        * 78
        * 49
        * 72
        * 81
        * 89
        * */
    }

    //在集合中使用泛型的情况：以HashMap为例
    @Test
    public void test3(){
//        Map<String,Integer> map = new HashMap<String,Integer>();//JDK7以后不这么写
        Map<String,Integer> map = new HashMap<>();//jdk7新特性：类型推断

        map.put("Tom",87);
        map.put("Tone",81);
        map.put("Jack",64);

//        map.put(123,"ABC");

        //泛型的嵌套
        Set<Map.Entry<String,Integer>> entry = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();

        while(iterator.hasNext()){
            Map.Entry<String, Integer> e = iterator.next();
            String key = e.getKey();
            Integer value = e.getValue();
            System.out.println(key + "----" + value);
        }
    }
    /*
    * Tom----87
    * Tone----81
    * Jack----64
    * */

}

package javase14;

import org.junit.Test;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Objects;
import java.util.TreeSet;

/**测试类*/
public class genericity2 {
    //使用自然排序,比较名字,由小到大排序,日期其实起不到什么作用,因为set不允许有重复数据。
    @Test
    public void test1(){
        TreeSet<Employee> set = new TreeSet<Employee>();

        Employee e1 = new Employee("wangxianzhi",41,new MyDate(334,5,4));
        Employee e2 = new Employee("simaqian",43,new MyDate(-145,7,12));
        Employee e3 = new Employee("yanzhenqin",44,new MyDate(709,5,9));
        Employee e4 = new Employee("zhangqian",51,new MyDate(-179,8,12));
        Employee e5 = new Employee("quyuan",21,new MyDate(-340,12,4));

        set.add(e1);
        set.add(e2);
        set.add(e3);
        set.add(e4);
        set.add(e5);

        Iterator<Employee> iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        /*
        * Employee{name='quyuan', age=21, birthday=MyDate{year=-340, month=12, day=4}}
        * Employee{name='quyuan1', age=21, birthday=MyDate{year=40, month=12, day=4}}
        * Employee{name='simaqian', age=43, birthday=MyDate{year=-145, month=7, day=12}}
        * Employee{name='wangxianzhi', age=41, birthday=MyDate{year=334, month=5, day=4}}
        * Employee{name='yanzhenqin', age=44, birthday=MyDate{year=709, month=5, day=9}}
        * Employee{name='zhangqian', age=51, birthday=MyDate{year=-179, month=8, day=12}}
        * */
    }

    //按照生日日期的先后排序
    @Test
    public void test2(){
        TreeSet<Employee> set = new TreeSet<>(new Comparator<Employee>() {//创建一个非匿名对象的匿名实现类
            @Override
            public int compare(Employee o1, Employee o2) {
                return o1.getBirthday().compareTo(o2.getBirthday());
            }

//            //使用泛型之前的写法
//            @Override
//            public int compare(Object o1, Object o2) {
//                if(o1 instanceof Employee && o2 instanceof Employee){
//                    Employee e1 = (Employee)o1;
//                    Employee e2 = (Employee)o2;
//
//                    MyDate b1 = e1.getBirthday();
//                    MyDate b2 = e2.getBirthday();
//                    //方式一：
//            //比较年
//            int minusYear = b1.getYear() - b2.getYear();
//                    if(minusYear != 0){
//                return minusYear;
//            }
//            //比较月
//            int minusMonth = b1.getMonth() - b2.getMonth();
//                    if(minusMonth != 0){
//                return minusMonth;
//            }
//            //比较日
//                    return b1.getDay() - b2.getDay();

                    //方式二：
                    return b1.compareTo(b2);

                }
//                return 0;
                throw new RuntimeException("传入的数据类型不一致！");
            }
        });

        set.add(new Employee("liudehua",55,new MyDate(1965,5,4)));
        set.add(new Employee("zhangxueyou",43,new MyDate(1987,5,4)));
        set.add(new Employee("guofucheng",44,new MyDate(1987,5,9)));
        set.add(new Employee("liming",51,new MyDate(1954,8,12)));
        set.add(new Employee("liangzhaowei",21,new MyDate(1978,12,4)));

        Iterator<Employee> iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());//按照日期排序
        }

        /*
        * Employee{name='liming', age=51, birthday=MyDate{year=1954, month=8, day=12}}
        * Employee{name='liudehua', age=55, birthday=MyDate{year=1965, month=5, day=4}}
        * Employee{name='liangzhaowei', age=21, birthday=MyDate{year=1978, month=12, day=4}}
        * Employee{name='zhangxueyou', age=43, birthday=MyDate{year=1987, month=5, day=4}}
        * Employee{name='guofucheng', age=44, birthday=MyDate{year=1987, month=5, day=9}}
        * */
    }
    
}

/**
 * 定义一个Employee类。
 * 该类包含：private成员变量name,age,birthday，
 * 其中birthday 为MyDate 类的对象；
 * 并为每一个属性定义getter, setter 方法；
 * 并重写toString 方法输出name, age, birthday
 *
 */
class Employee implements Comparable<Employee>{
    private String name;
    private int age;
    private MyDate birthday;

    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;
    }

    public MyDate getBirthday() {
        return birthday;
    }

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

    public Employee() {
    }

    public Employee(String name, int age, MyDate birthday) {
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

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

    //没有指明泛型时的写法
    //按name排序
//    @Override
//    public int compareTo(Object o){
//        if(o instanceof Employee){
//            Employee e = (Employee)o;
//            return this.name.compareTo(e.name);
//        }
//        throw new RuntimeException("传入的数据类型不一致");
//    }

    //指明泛型时的写法
    @Override
    public int compareTo(Employee o) {
        return this.name.compareTo(o.name);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return age == employee.age &&
                Objects.equals(name, employee.name) &&
                Objects.equals(birthday, employee.birthday);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, birthday);
    }
}

/**
 * MyDate类包含:
 * private成员变量year,month,day；并为每一个属性定义getter,  setter 方法；
 *
 */
class MyDate implements Comparable<MyDate>{
    private int year;
    private int month;
    private int 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;
    }

    public MyDate() {
    }

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

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

//    @Override
//    public int compareTo(Object o) {
//        if(o instanceof MyDate){
//            MyDate m = (MyDate)o;
//
//            //比较年
//            int minusYear = this.getYear() - m.getYear();
//            if(minusYear != 0){
//                return minusYear;
//            }
//            //比较月
//            int minusMonth = this.getMonth() - m.getMonth();
//            if(minusMonth != 0){
//                return minusMonth;
//            }
//            //比较日
//            return this.getDay() - m.getDay();
//        }
//
//        throw new RuntimeException("传入的数据类型不一致！");
//
//    }

    @Override
    public int compareTo(MyDate m) {
        //比较年
        int minusYear = this.getYear() - m.getYear();
        if(minusYear != 0){
            return minusYear;
        }
        //比较月
        int minusMonth = this.getMonth() - m.getMonth();
        if(minusMonth != 0){
            return minusMonth;
        }
        //比较日
        return this.getDay() - m.getDay();
    }
}

自定义泛型

自定义泛型类

在不确定类成员的类型时可以使用泛型表示该类为泛型类,这里泛型可以使用<T>,也可以使用<E>.都能表示任意的类型的意思
泛型可以被继承,如果子类继承了泛型父类并指明了类型,那么子类在实例化的时候不需要声明泛型。且子类就是一个普通的类
子类和父类都没有指明类型,此时子类任然是泛型类
子类没有指明类型,父类指明了类型,此时子类任然是泛型类,但从父类继承的都变成了指定类型
泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：<E1,E2,E3>
```
public interface Map<K,V> {...}
```
声明泛型类的构造器如下：public GenericClass(){}。
而后面声明泛型构造器是错误的：public GenericClass<E>(){}
实例化的时候要加上<>：new GemericClass<>();
实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
泛型不同的引用不能相互赋值。尽管在编译时ArrayList<String>和ArrayList<Integer>是两种类型，但在运行时只有一个ArrayList被加载到JVM中。
```
ArrayList<String> list1 = new ArrayList<String>;
ArrayList<Integer> list2 = new ArrayList<Integer>;

//list1 = list2;//编译异常,泛型同的引用不能互相赋值
```
泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object(后面会补充说明)。
经验：泛型要使用就一直都用。要不用，就一直不要用。
如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象,因为接口和抽象类都不能创建对象。

jdk7 泛型的简化操作

//        Map<String,Integer> map = new HashMap<String,Integer>();//JDK7以后不这么写
        Map<String,Integer> map = new HashMap<>();//jdk7新特性：类型推断
        int[] i1 = {1,2,3};//类型推断,省略了"new int[]"的数组的静态声明

(强调)泛型的指定中不能使用基本数据类型，可以使用包装类替换。
在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以用作在非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型,因为静态资源和类一同被加载到方法区,早于对象创建在堆内存中,而泛型指定是在对象创建时候指定的,因此不能在静态资源中使用泛型。但是可以用在泛型方法中(后面会提及)
异常类不能是泛型的

创建泛型数组要注意

    //创建泛型数组需要注意的地方
    T[] arr = new T[10];//编译异常,类型参数T不能直接实例化,因为T是一个泛型变量,new是创建一个实例对象,是有具体类型的对象,如果选择用T就是不确定类型,是不容许的
    T[] arr = (T[]) new Object[10];//正确的泛型数组写法,需要创建一个Object类型数组然后强转成类型参数数组,里面存放的元素都要是T类型对象或者T的子类类型对象

异常类不能是泛型

//异常类不能是泛型
class MyException<T> extends Exception{//编译异常

        public void fly(){
        try {
            System.out.println("TryCatch方法");
        } catch (T e) {//编译异常,异常类不能是泛型
        }
    }
 }

父类有泛型,子类可以选择保留泛型或者选择指定泛型

//父类声明
class Father<T1, T2> {}
// 子类不保留父类的泛型,因为继承的父类一个泛型也没有声明泛型
// 1)没有类型擦除
class Son1 extends Father {// 等价于class Son extends Father<Object,Object>{}
}

// 2)子类继承父类声明的具体泛型
class Son2 extends Father<Integer, String> {}

// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2> extends Father<T1, T2> {}
// 2)部分保留,因为部分泛型已经被父类实现,子类无法覆盖父类声明的具体泛型,T1写上去也没有意义
class Son4</*T1,*/T2> extends Father<Integer, T2> {}

// 子类虽然不能覆盖父类的泛型,但是可以有自己独有的泛型参数A,B.
class son5<T2,A,B> extends Father<Integer,T2>{}

package javase14;

import org.junit.Test;


public class genericity3 {
    //测试泛型类
    @Test
    public void test1(){
        //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
        Order o1 = new Order();
        o1.setOrderT(123);
        o1.setOrderT("ABC");
        //在实例化时要指明类的泛型
        Order<String> o2 = new Order<String>("orderAAA",1001,"order:AAA");
        System.out.println(o2.orderT.getClass());//class java.lang.String

        //子类继承了泛型父类,并且泛型父类指明了类型,那么子类在实例化的时候不需要声明泛型。
        SubOrder1 o3 = new SubOrder1();
        o3.orderT = "你好啊";//String orderT

        //子类和父类都没有指明类型,此时子类任然是泛型类
        SubOrder2<String> o4 = new SubOrder2<>();
        o4.orderT = "你好啊";//String orderT

        //子类没有指明类型,父类指明了类型
        SubOrder3<Double> o5 = new SubOrder3<>();
        o5.orderT = "你好啊";//String orderT,从父类继承的都变成了指定类型
        o5.orderPrice = 9.9;
        System.out.println(o5.orderPrice.getClass());//class java.lang.Double,子类独有的属性和自定义的类型
    }
}

//在不确定类成员的类型时可以使用泛型表示该类为泛型类,这里泛型可以使用<T>,也可以使用<E>.都能表示任意的类型的意思
class Order<T>{

    String orderName;
    int orderId;

    /*在类或接口上声明的泛型，在本类或本接口中即代表某种类型，可以作在非静态属性的类型、
    非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型,
    因为静态资源和类一同被加载到方法区,早于对象创建在堆内存中,而泛型指定是在对象创建时候指定的,
    因此不能在静态资源中使用泛型*/
    T orderT;//属性可以使用

    public Order() {
    }

    public Order(String orderName, int orderId, T orderT) {//形参可以使用
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    //getter setter 方法也可以使用
    public T getOrderT() {
        return orderT;
    }

    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }

//    public static T fly(T ordert){//编译异常,泛型不能用在静态资源
//        return ordert;
//    }
}

//泛型可以被继承,如果子类继承了泛型父类并指明了类型,那么子类在实例化的时候不需要声明泛型。
class SubOrder1 extends Order<String>{

}

//子类和父类都没有指明类型,此时子类任然是泛型类
class SubOrder2<T> extends Order<T>{

}

//子类没有指明类型,父类指明了类型,此时子类任然是泛型类,但从父类继承的都变成了指定类型
class SubOrder3<T> extends Order<String>{
    T orderPrice;
}

//异常类不能是泛型
//class MyException<T> extends Exception{}//异常

自定义泛型方法

什么是泛型方法？

方法出现了泛型结构
静态方法也可以使用泛型结构变成静态泛型方法，因为在调用方法时已经声明了泛型方法的泛型参数，并非在实例化时才会被确定。（再次强调）但是泛型类的泛型参数不能使用在静态方法中
无论泛型方法是否处于泛型类或者泛型接口中，他都可以被自定义成泛型类。使用了类或者接口的泛型参数的方法称之为普通方法，和泛型方法一点关系都没有。

泛型方法结构分析:

//[访问权限] <泛型> 返回类型  方法名([泛型标识参数名称]) 抛出的异常
如：public static <E>  List<E> copyFromArrayToList(E[] arr)　throws  Exception{  }

例如Collection泛型接口里的toArray泛型方法和普通方法

public interface Collection<E> extends Iterable<E> {//泛型接口
    <T> T[] toArray(T[] a);//泛型方法,与泛型接口的泛型参数<E>没有任何关系.这里有不确定的数组类型的方法形参;不确定数组类型的返回值;告知编译器他是一个泛型方法,泛型参数为<T>
    boolean add(E e);//泛型接口的普通方法
}

再例如自定义一个泛型方法,用于任意类型的数组传进来转换任意类型List集合

    public static <E> List<E> copyFromArrayToList(E[] arr){

        ArrayList<E> list = new ArrayList<>();

        for(E e : arr){
            list.add(e);
        }
        return list;

    }

代码演示自定义泛型方法

package javase14;

import org.junit.Test;

import java.util.*;

public class genericity4 {

    //泛型方法测试
    @Test
    public void test1() {
        Integer[] i = {1,2,3,4,5};
        List<Integer> list = ArrayToList.arrayToList(i);
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        /*
        *1
        * 2
        * 3
        * 4
        * 5
        * */
    }

    //泛型类和泛型方法的使用
    @Test
    public void test2() {
        DAO<String> stringDAO = new DAO<>();//设定泛型类DAO的对象的泛型参数为String
        stringDAO.add("你好啊");//控制台打印"class java.lang.String",证明泛型类对象的参数是String
        Integer integer = stringDAO.get(6666);//使用泛型方法指明泛型方法的泛型参数
        System.out.println(integer);//6666
    }

    //模拟DAO操作演示泛型类的使用
    @Test
    public void test3() {
        CustomerDAO dao1 = new CustomerDAO();//创建一个能够对指定数据表操作的具体对象,这个指定数据库已经在类声明的时候被设置

        dao1.add(new Customer());//因此方法传入的参数也被确定,因为add普通方法在声明时使用了泛型参数
    }
}

class ArrayToList{//非泛型类中泛型方法

    public static <E> List<E> arrayToList(E[] arr){//泛型方法

        ArrayList<E> list = new ArrayList<>();//使用泛型方法的泛型参数创建一个集合对象

        for(E e : arr){//使用泛型参数遍历数组将元素存入到List集合
            list.add(e);
        }
        return list;//返回存好元素的集合
    }
}

class DAO<T>{//操作数据库的泛型类,可以对任意的数据表进行DAO操作

    //通用的操作数据库方法
    public <E> E get(E e){//泛型方法
        return e;
    }

    public void add(T t){//普通方法使用泛型类的泛型参数
        System.out.println(t.getClass());
    }
}

class Customer { //此类对应数据库中的具体的数据表及里面的具体数据
}

class CustomerDAO extends DAO<Customer>{//指定了数据库的泛型类为什么类型的泛型参数,因此该类只能对指定的数据表进行DAO操作
}