Java之泛型详解

版权声明：欢迎转载，转载请注明出处哦！ https://blog.csdn.net/qq_41647999/article/details/88839632

一、 为什么要使用泛型？

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

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

二、 在哪里使用泛型？

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){

    }
}