Java之泛型详解

雨点打透心脏的1/2处 2022-02-27 08:50 218阅读 0赞

# 一、 为什么要使用泛型？ #

1、 解决元素存储的安全性问题。

2、 解决获取数据元素时，需要类型强转的问题。

![20190327094545307.png][]

# 二、 在哪里使用泛型？ #

## 1、在集合中使用泛型与不使用泛型对比 ##

import java.util.*;
    
    public class TestGenericParadigm {
        public static void main(String[] args) {
    
          test1();
    
          test2();
    
          test3();
        }
    
        /**
         * 没有使用泛型的情况
         */
        public static void test1(){
            System.out.println("--------- test1 ----------");
            List list = new ArrayList();
            list.add(123);
            list.add(1234);
            list.add("AA");
            list.add(new Date());
            list.add(456);
    
            Iterator iterator = list.iterator();
            while (iterator.hasNext()){
                Object ob = iterator.next();
                if (ob.equals(1234)){
                    iterator.remove();
                }else {
                    System.out.println(ob);
                }
            }
        }
    
        /**
         * 使用泛型
         * 泛型实际上就是指明了所有 list 元素的类型
         */
        public static void test2(){
            System.out.println("--------- test2 ----------");
            List<Integer> list = new ArrayList<>();
            list.add(123);
            list.add(345);
            Iterator iterator = list.iterator();
            while (iterator.hasNext()){
                Object ob = iterator.next();
                if (ob.equals(1234)){
                    iterator.remove();
                }else {
                    System.out.println(ob);
                }
            }
        }
    
        /**
         * Map 的泛型
         */
        public static void test3(){
            System.out.println("--------- test3 ----------");
            Map<String,Integer> map = new HashMap<>();
            map.put("djun",21);
            map.put("AA",23);
            map.put("BB",22);
    
            // 第一种  需强转的遍历方式
            Set set = map.entrySet();
            for (Object o : set){
                Map.Entry entry = (Map.Entry) o;
                System.out.println(entry.getKey() + " => " + entry.getValue());
            }
            // 第二种 不需要强转的遍历方式
            Set<Map.Entry<String,Integer>> s = map.entrySet();
            for (Map.Entry<String,Integer> obj: s){
                System.out.println(obj.getKey() + " => " +obj.getValue() );
            }
        }
    }

## 2、 自定义泛型类、泛型方法、泛型接口 ##

具体知道如何使用代码来实现即可，废话不多说请看下方代码：

import java.util.ArrayList;
    import java.util.List;
    
    public class TestOrder {
        public static void main(String[] args) {
            test1();
            System.out.println("----------------");
            test2();
        }
        public static void test1(){
            Order<Boolean> order = new Order<>();
            order.setT(Boolean.TRUE);
            order.add();
            order.setOrderId(123);
            order.setOrderName("djun");
    
            System.out.println(order.getT());
            System.out.println(order.getOrderId());
            System.out.println(order.getOrderName());
    
    
        }
    
        public static void test2(){
            Order<Boolean> order2 = new Order<>();
            Integer [] in = new Integer[]{1,2,3};
            List<Integer> list2 = new ArrayList<>();
            List<Integer> list3 = order2.fromArryList(in,list2);
            System.out.println(list3);
        }
    }
    /**
     * 自定义泛型类
     */
    class Order<T>{
        private String orderName;
        private int orderId;
        private T t;
        List<T> list = new ArrayList<>();
    
        public void add(){
            list.add(t);
        }
    
        // 将list的元素加入到数组e
        public <E> List<E> fromArryList(E[] e,List<E> list){
            for (E e1 : e){
                list.add(e1);
            }
            return list;
        }
        public String getOrderName() {
            return orderName;
        }
    
        public void setOrderName(String orderName) {
            this.orderName = orderName;
        }
    
        @Override
        public String toString() {
            return "order{" +
                    "orderName='" + orderName + '\'' +
                    ", orderId=" + orderId +
                    ", t=" + t +
                    '}';
        }
    
        public int getOrderId() {
            return orderId;
        }
    
        public void setOrderId(int orderId) {
            this.orderId = orderId;
        }
    
        public T getT() {
            return t;
        }
    
        public void setT(T t) {
            this.t = t;
        }
    }

## 3、 泛型与继承的关系与通配符 ##

白话详解请看代码注释，学习需要沉淀，需要静下心。

import java.util.ArrayList;
    import java.util.List;
    
    public class TestOrder {
        public static void main(String[] args) {
            test3();
        }
     
        /**
         * 1. 通配符：？
         * List<A>   List<B>
         * 2. 泛型与继承的关系
         *
         * 若A是类B的子类，那么List<A> 就不是List<B>的子接口。
         */
        public static void test3(){
            List<?> list1 = null ;
            List<Object> list2 =new ArrayList<>();
            List<String> list3 = new ArrayList<>();
            // 下面说明一个问题：list1是list2和list3的父类
            list1 = list2;
            list1 = list3;
            show(list2);
    //        下面这个String类型的list2报错了
    //        说明这样的是不行的
    //        show(list3);
    //        但是下面的show2使用了通配符就可以了
            show2(list2);
            show2(list3);
            List<? extends Number> list4 = null;
            List<Integer> list5 = null;
            list4 = list5;
    
    
            // list4 = list2;
            List<? super Number> list6 = null;
            list6 = list2;
    
        }
        public static void show(List<Object> list){
    
        }
        public static void show2(List<?> list){
    
        }
    }

[20190327094545307.png]: /images/20220227/c778cac320f74a1ba8482e02b9551312.png