带你了解Java高级编程-----泛型

一、泛型简介

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。换句话说就是起到了对数据的类型的限制作用。

Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮。
解决的主要问题：

• 解决了元素存储的安全性问题；
• 解决了获取元素时，需要类型强制转换的问题；

二、泛型的使用

泛型最多的还是集合中使用。

①在实例化集合类时，可以指明具体的泛型类型 ；
②指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法，构造器，属性等）使用

• 比如：add（E e） ----->实例化以后 ： add（Integer e)

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

• 下面的例子演示了如何使用泛型方法打印不同类型的数组元素：

/**
 * 下面的例子演示了如何使用泛型方法打印不同类型的数组元素：
 * @Author duokanzhouzhou
 * @Create 2021/8/15
 */
public class GenericArrayTest {
    public static <E> void printArray(E[] inputArray){
        for (E ele : inputArray){
            System.out.print(ele);
        }
        System.out.println();
    }


    public static void main(String[] args) {
        Integer[] intArray = {1,2,3,4,5,6};
        Double[] doubleArray = {1.2,2.3,4.2,6.5,7.7};
        Character[] charArray = {'A','E','P','I'};

        printArray(intArray);
        printArray(doubleArray);
        printArray(charArray);
    }
}

• 下面是在集合中的使用情况：

public class GenericTest {
    @Test
    /*在集合中使用泛型之前的情况 :*/
    public void test1(){
        ArrayList arrayList = new ArrayList();
        //需求: 存入学生的成绩
        arrayList.add(123);
        arrayList.add(234);
        arrayList.add(33);
        arrayList.add(93);
        /*  问题一 ： 类型不安全   */
        //arrayList.add("MM");

        for (Object score : arrayList){
            /* 问题二 ： 强转时，可能出现ClassCastException */
            int s = (Integer) score;
            System.out.println(score);
        }
    }

    @Test
    /**
     * 在集合中使用泛型的情况 ：
     */
    public void test2(){
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        //需求: 存入学生的成绩
        arrayList.add(123);
        arrayList.add(234);
        arrayList.add(33);
        arrayList.add(93);
        //编译时，就会进行类型检查，保证数据的安全
        //arrayList.add("MM");//非学生成绩
        /**
         * 方式一：
         for (Integer score : arrayList){
         //避免了强转操作
         int stuScore = score;
         System.out.println(stuScore);
         }
         */
        //方式二：
        Iterator<Integer> iterator = arrayList.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    @Test
    public void test3(){
        HashMap<String, Integer> map = new HashMap<String,Integer>();
        map.put("Tom",123);
        map.put("Jerry",333);
        map.put("Bob",321);
        //map.put(123,"asd");  //报错

        //泛型的嵌套：泛型里面放泛型，只有特定的结构才可以使用
        Set<Map.Entry<String, Integer>> entry = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();

        while (iterator.hasNext()){
            Map.Entry<String, Integer> entry1 = iterator.next();
            String key = entry1.getKey();
            Integer value = entry1.getValue();
            System.out.println(key + "----" + value);
        }
    }

}

三、自定义泛型结构

泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。

和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。

下面是定义泛型方法的规则：

• ①所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的）。
• ②每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
• ③类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
• ④泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像int,double,char的等）。

import org.junit.Test;

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

public class GenericTest2 {

    @Test
    public void test1(){
        //如果定义了泛型类，实例化没有指明类的泛型，则认此泛型类型为Object类型
        /* 要求： 如果定义了类是带泛型的，建议在实例化时呀指明类的泛型 */
        Order order = new Order();
        order.setOrderT(123);
        order.setOrderT("ABC");

        //建议： 实例化时指明类的泛型
        Order<String> order1 = new Order<String>("orderAA",001,"order: AA");
        order1.setOrderT("AA : hello");
    }

    @Test
    public void test2(){
        Suborder sub1 = new Suborder();
        //由于子类在继承带泛型的父类时，指明了泛型类型，则是实例化子类对象时，不需要再指明泛型的类型
        sub1.setOrderT(002);

        Suborder2<Object> sub2 = new Suborder2<>();
        sub2.setOrderT("order2...");
    }

    @Test
    public void test3(){
        //泛型不同的引用不能相互赋值

        ArrayList<String> list1 = null;
        ArrayList<Integer> list2 = null;

        /* list1 = list2; */
        // 不兼容的类型: java.util.ArrayList无法转换为java.util.ArrayList
    }

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

        System.out.println(list);
    }
}

/**
* 自定义泛型类
*/
public class Order<T>{

    String orderName;
    int orderID;
    //类的内部结构就可以使用类的泛型
    T orderT;   //把 T 看成一个类

    public Order(){
     //编译不通过
     /* T[] arr = new T[20]; */
        T[] arr =(T[]) new Object[10]; //此写法正确
    }

    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(){
        System.out.println(orderT);
    }*/
    //泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
    //换句话说，泛型方法所属的类是不是泛型类都没有关系
    //泛型方法，可以声明为静态。原因：泛型参数是在调用方法时确定的，并非在实例化类时确定。
    public static <E> List<E> copyFromArrayToList(E[] arr){
        ArrayList<E> list = new ArrayList<>();
        for (E e : arr){
            list.add(e);
        }
        return list;
    }
}

四、泛型在继承上的体现

public class GenericTest {

    /*
       1.泛型在继承方面的体现
       虽然类A是类B的父类，但是 G 和 G 不具备子父类关系，二者是并列关系。
       补充：类A是类B的父类，A 和 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;*/

        List<Object> list1 = null;
        List<String> list2 = new ArrayList<String>();
        //此时的list1和list2的类型不具有子父类关系
        /* list1= list2; */

        show1(list1);
        show2(list2);

    }
        public void show1(List<Object> list){
        }
        public void show2(List<String> list){

        }


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

        list1 = list3;
        list2 = list3;
       ArrayList<String> list = new ArrayList<>();
   }

}

五、通配符的使用

• 1、类型通配符一般是使用?代替具体的类型参数。例如 List 在逻辑上是List,List 等所有List<具体类型实参>的父类。
• 2、类型通配符上限通过形如List来定义，如此定义就是通配符泛型值接受父类及其下层子类类型。

class Person{
}

class Stu extends Person{
}
  @Test
   /*
    通配符的使用  "?" ; 类A是类B的父类，G 和 G 是没有关系的，二者共同的父类是：G
    */
   public void test3(){
       List<Object> list1 = null;
       List<String> list2 = null;

       List<?> list = null;

       list = list1;
       list = list2;

       //
       ArrayList<String> list3 = new ArrayList<>();
       list3.add("AA");
       list3.add("BB");
       list3.add("CC");
       list = list3;
       //添加：对于List就不能向起内部添加数据
       //【除了添加null除外】
       /*
       list.add("DD");
       list.add("?");//java: 不兼容的类型: java.lang.String无法转换为capture#1, 共 ?
       */
       list.add(null);
       //获取(读取)：允许读取数据，读取的数据类型为Object
       Object o = list.get(0);
       System.out.println(o);
   }
   public void print(List<?> list){
       Iterator<?> iterator = list.iterator();
       while(iterator.hasNext()){
           Object obj = iterator.next();
           System.out.println(obj);
       }
   }
   /*
   * 3.有限制条件的通配符的使用
   * ? extend A :
   *            G 可以作为G和G的父类，其中B是A的子类
   * ? super A :
   *            G 可以作为G和G的父类，其中B是A的父类
   */
    @Test
    public void test4(){
        List<? extends Person> list1 = null;  //    (-∞,Person]  <=
        List<? super Person> list2 = null;    //    [Person,+∞)  >=

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

        //region 有限制条件的通配符的赋值情况
        list1 = list3;
        list1 = list4;
        /* list1 = list5; */

        /* list2 = list3; */
        list2 = list4;
        list2 = list5;
        //endregion

        //region 读取数据【用最大的对象去调】
        list1 = list3;
        Person p = list1.get(0);
        /* Student s = list1.get(0); */

        list2 = list4;
        Object o = list2.get(0);
        /* Process p1 = list2.get(0); */
        //endregion

        //region 写入数据【添加的对象和？进行比较】
        /* list1.add(new Student()); */
        list2.add(new Person());
        list2.add(new Student());
        //endregion
    }