当前位置：自学咖网 > 技术教程 > 编程最新 > Java中的泛型
wenwen 编程最新

Java中的泛型

Java中的泛型

泛型的使用

泛型是jdk5.0新增的特性。
在集合中使用泛型的总结：

  • 集合接口或集合类在jdk5.0时都修改为带泛型的结构。
  • 在实例化集合类时，可以指明具体的泛型类型。
  • 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构(比如：方法、构造器、属性等)使用到类的泛型的位置，都指定为实例化时的泛型类型。比如：add(E e) —-> 实例化以后：add(Integer e)

注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换。
如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型。

在集合中使用泛型之前的情况

    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        //需求：存放学生成绩
        list.add(78);
        list.add(76);
        list.add(89);
        list.add(88);
        //问题一：类型不安全
//        list.add("Tom");
        for (Object score : list) {
            //问题二：强转时，可能出现ClassCastException
            int stuScore = (int) score;
            System.out.println(stuScore);
        }
    }

ArrayList集合使用泛型

    @Test
    public void test2(){
        ArrayList<Integer> list = new ArrayList<>();
        list.add(78);
        list.add(76);
        list.add(89);
        list.add(88);
        //编译时，就会进行类型检查，保证数据的安全
//        list.add("Tom");
        //方式一：
//        for (Integer score : list) {
//            //避免了强转操作
//            int stuScore = score;
//            System.out.println(stuScore);
//        }
        //方式二：
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            Integer stuScore = iterator.next();
            System.out.println(stuScore);
        }
    }

HashMap集合使用泛型

    @Test
    public void test3(){
//        HashMap<String, Integer> map = new HashMap<String, Integer>();
        //jdk7新特性：类型推断
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Tom",87);
        map.put("Jerry",87);
        map.put("Jack",67);
        //泛型的嵌套
        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);
        }
    }

自定义泛型结构的注意点

泛型结构包含泛型类、泛型接口以及泛型方法。
关于自定义泛型类、泛型接口的一些注意点：

  • 如果子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型。
  • 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如:<E1,E2,E3>
  • 泛型类的构造器如下:public GenericClass(){},而右边则是错误的:public GenericClass(){}
  • 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
  • 泛型不同的引用不能相互赋值。
  • 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。建议:泛型要使用一路都用。要不用，一路都不要用。
  • 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
  • jdk1.7新增泛型的简化操作（类型推断）：ArrayList flist = new ArrayList<>();
  • 泛型的指定中不能使用基本数据类型，可以使用包装类替换。
  • 静态方法中不能使用类的泛型。
  • 异常类不能声明为泛型类。
  • 不能使用new E[]。但是可以:E[] elements = (E[])new Object[capacity];

自定义泛型类

自定义泛型类

//自定义泛型类
public 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;
    }
    //如下的三个方法都不是泛型方法
    public T getOrderT() {
        return orderT;
    }
    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }
    @Override
    public String toString() {
        return "Order{" +
                "orderName="" + orderName + """ +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                "}";
    }
    //静态方法中不能使用类的泛型。
//    public static void show(T orderT){
//        System.out.println(orderT);
//    }
}

测试自定义的泛型类

    @Test
    public void test1(){
        //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
        //要求：如果定义了类是带泛型的，建议在实例化时要指明类的泛型。
        Order order = new Order();
        order.setOrderT(123);
        order.setOrderT("ABC");
        //建议：实例化时指明类的泛型
        Order<String> order1 = new Order<>("orderAA",1001,"order:AA");
        order1.setOrderT("AA:hello");
    }

自定义泛型方法

泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
泛型方法所属的类是不是泛型类都没有关系。
泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并发在实例化类时确定的。

    public <E> ArrayList<E> copyFromArrayToList(E[] arr) {
        ArrayList<E> list = new ArrayList<>();
        for (E e : arr) {
            list.add(e);
        }
        return list;
    }

测试自定义的泛型方法

    @Test
    public void test2(){
        Order<String> order = new Order<>();
        Integer[] arr = {1,2,3,4};
        //泛型方法在调用时，指明泛型参数的类型。
        ArrayList<Integer> list = order.copyFromArrayToList(arr);
        System.out.println(list);
    }

泛型在继承方面的体现

虽然A是B的父类，但是G<A>和G<B>二者不具备子父类关系，二者是并列关系。
测试代码

    @Test
    public void test1() {
        Object obj = null;
        String str = null;
        obj = str;
        Object[] arr1 = null;
        String[] arr2 = null;
        arr1 = arr2;
        //编译不通过
//        Date date = new Date();
//        str = date;
        ArrayList<Object> list1 = null;
        ArrayList<String> list2 = null;
        //此时的list1和list2的类型不具有子父类关系
        //编译不通过
//        list1 = list2;
//使用反证法证明：假设list1 = list2;成立。则调用list1.add(123);会导致混入非String的数据，出错。
    }

补充：类A是类B的父类，A<G> 是 B<G>的父类。

    @Test
    public void test2(){
        AbstractList<String> list1 = null;
        ArrayList<String> list2 = null;
        list1 = list2;
    }

通配符的使用

为解决上述问题，Java引入了通配符：?
类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>
注意：不能对ArrayList<?>其内部添加数据（除开null，但向其中添加null也意义不大）。
ArrayList<?>允许读取数据，读取的数据类型为Object。

    @Test
    public void test3(){
        ArrayList<Object> list1 = null;
        ArrayList<String> list2 = null;
        ArrayList<?> list = null;
        list = list1;
        list = list2;
//        编译通过
//        print(list1);
//        print(list2);
        ArrayList<String> list3 = new ArrayList<>();
        list3.add("AA");
        list3.add("BB");
        list = list3;
        //添加(写入)：对于ArrayList<?>就不能向其内部添加数据。
        //除了添加null之外。
//        list.add("CC");
        list.add(null);
        //获取(读取)：允许读取数据，读取的数据类型为Object。
        Object o = list.get(0);
        System.out.println(o);
    }

    public void print(ArrayList<?> list) {
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.hasNext();
            System.out.println(obj);
        }
    }

有限制条件的通配符的使用

? extends A: G<? extends A> 可以作为G<A>和G<B>的父类，其中B是A的子类
? super A: G<? super A> 可以作为G<A>和G<B>的父类 ，其中B是A的父类

    @Test
    public void test4() {
        ArrayList<? extends Person> list1 = null;
        ArrayList<? super Person> list2 = null;

        ArrayList<Student> list3 = new ArrayList<>();
        ArrayList<Person> list4 = new ArrayList<>();
        ArrayList<Object> list5 = new ArrayList<>();

        list1 = list3;
        list1 = list4;
//        list1 = list5;

//        list2 = list3;
        list2 = list4;
        list2 = list5;

        //读取数据
        list1 = list3;
        Person p = list1.get(0);
        //编译不通过
//        Student s = list1.get(0);

        list2 = list4;
        Object obj = list2.get(0);
        //编译不通过
//        Person obj = list2.get(0);

        //写入数据：
        //编译不通过
//        list1.add(new Student());

        //编译通过
        list2.add(new Person());
        list2.add(new Student());
    }
hmoban主题是根据ripro二开的主题，极致后台体验，无插件，集成会员系统
自学咖网 » Java中的泛型

wen 普通

分享到：

相关推荐

django自带的序列化组件

1.什么是序列化组件 在django中，自带一个序列化组件，它是用来将数据进行整理、转化成特定的为一个特定的格式（比如json数据格式），然后传输给前端，以便前端对数据进行处理操作。 2.为什么要用序列化组件 当我们从数...

大数相关问题总结

常考 大数乘法 题目链接：https://leetcode-cn.com/problems/multiply-strings/ class Solution { public: string multiply(strin...

python笔记：纵向合并表格

工作中我们常常遇到多个格式相同的表格面要合并成一个表格，比如将2019年的数据与2020年的数据合并在一起来进行分析。平时EXCEL时我们通常直接复制粘贴，但有时因表格内容过大，直接粘贴效率低，且当字段过多时还需要进行逐...