20210325Java泛型

Java泛型

编辑时间：2021/03/25

读完本节：大概花费15钟，共2375词

1.泛型的设计背景

1. 集合容器类在设计阶段、声明阶段不能确定这个容器到底实际存在的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候处理元素的类型不确定，其他部分是确定的，因此把元素的类型设置成一个参数，这个类型的参数叫泛型。

2.泛型的概念

1. 所谓泛型就是允许在定义类、接口；方法时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（继承、实现接口、声明方法时）确定（即传入的实际的类型参数，也成为类型实参）
2. 从JDK1.5之后，Java引入了“参数化类型（Parameterized type）”的概念，允许我们在创建集合时再指定元素的类型，如List<String>，这表明该List只能保存字符串类型的对象
3. JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以再声明集合变量、创建集合对象时传入类型实参

3.使用泛型和直接使用Object类型的区别

1. 解决元素存储得到安全性问题，即任何类型都可以添加到集合中
2. 解决获取元素时，需要类型强制转换的问题，避免出现类型转换出现异常：ClassCastException

4.在集合中使用泛型

1. 集合接口或集合类在JDK1.5时都修改为带泛型的结构

2. 在实例化集合类时，可以指明具体的泛型类型

3. 指明具体的泛型类型之后，在集合类或接口中凡是定义类或接口时，内部结构（如：方法、构造器、属性等）使用到泛型的位置，都指定为实例化的泛型类型。如声明为 add(E e)在完成实例化之后是add(Integer e)

4. 集合中使用泛型的注意点，泛型的类型必须是类，不能是基本数据类型。需要拥戴基本数据类型的位置，拿包装类替代

5. 如果没有实例化时，没有指明泛型的类型，默认类型为java.lang.Object类型

   import org.junit.Test;
   
   import java.util.*;
   
   /**
    * @Author: xuehai.XUE
    * @MailBox: xuehai.xue@qq.com
    * @Date: 2021/3/25 12:53
    * @Description:
    */
   public class GenericTest {
   
       @Test
       /** 在集合中未使用泛型的情况 */
       public void test1(){
           ArrayList list = new ArrayList();
   
           //需求：list存放整型数据
           list.add(485);
           list.add(85);
           list.add(4895);
           list.add(5547);
           //问题一：类型不安全
           list.add("tom");
   
           for (Object o : list){
               //问题二：可能出现ClassCastException
               int i = (Integer)o;
               System.out.println(i);
           }
       }
   
       @Test
       /** 在集合中使用泛型的情况 */
       public void test2(){
           //后一个尖括号内可以不写类型 ，JDK1.7起支持自动类型推断
           ArrayList<Integer> list = new ArrayList <>();
   
           //需求：list存放整型数据
           list.add(485);
           list.add(85);
           list.add(4895);
           list.add(5547);
           //问题解决：类型不安全，在使用泛型之后，编译时就会进行类型检查，保证数据的安全
   //        list.add("tom");
   
           //遍历的方式一
           for (Object o : list){
               //问题解决：使用泛型后，直接避免了强制转换的操作
               System.out.println(o);
           }
   
           //遍历的方式二
           Iterator<Integer> iterator = list.iterator();
           while(iterator.hasNext()){
               int i = iterator.next();
               System.out.println(i);
           }
       }
   
       @Test
       /** 在集合中使用泛型的情况，以hashMap为例 */
       public void test3(){
           Map<String,Integer> map = new HashMap<String,Integer>();
   
           map.put("biggy", 22);
           map.put("bobo", 21);
           map.put("zonwen",23);
   
           //按照泛型传入的参数类型，自动检查类型
   //        map.put(123,456);
   
           //泛型的嵌套使用
           Set<Map.Entry<String, Integer>> entry = map.entrySet();
           Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
   
       }
   }
   

5.自定义泛型结构：泛型类、泛型接口；泛型方法

1. 如果定义了泛型类，实例化没有指明泛型的类型，则认为此泛型类型为Object类型。如果在定义了带泛型的类，那么在实例化时建议指明泛型的类型

2. 当子类继承父类时，指明了父类中声明的泛型类型。则在实例化子类对象时，不需要指明泛型。

3. 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内，例：<E1,E2,E3>

4. 泛型类的构造器不能声明泛型

5. 实例化后，操作原来泛型的位置的结构必须与指定的泛型类型一致

6. 泛型不同的引用不能相互赋值

   1. 尽管在编译时ArrayList<String>和ArrayList<Integer>是两种类型，但是在运行时只有一个ArrayList被加载到JVM中

7. 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object

8. 如果泛型类是一个接口或抽象类，则不可创建泛型类的对象

9. JDK1.7，泛型的简化操作（自动类型推断）：ArrayList<ElementType> element = new ArrayList<>();

10. 泛型的指定中不能使用基本数据类型，可以使用包装类来替换

11. 在类、接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但是在静态方法中不能使用类的泛型。原因是当一个类的对象还未调用类的构造器时，静态方法，静态常量等静态结构已经在内存中被创建，而泛型中指定的元素类型只有在类的对象被实例化后，才能确定，因此不能在静态方法中使用类的泛型

12. 不能使用new E[]。但是可以E[] elements = (E[])new Object[capacity];

13. 父类声明包含泛型，子类可以选择保留泛型，也可以选择指定泛型的类型：

    1. class SuperClass<T1,T2>{}

    2. 子类不保留父类的泛型：按需实现

       1. 子类声明的泛型没有具体的类型→擦除：

          class SubClass1 extends SuperClass{}

          class SubClass1<A,B> extends SuperClass{}

       2. 子类声明的泛型存在具体类型：

          class SubClass2 extends<Integer,String>{}

          class SubClass2<A,B> extends<Integer,String>{}

    3. 子类保留父类的泛型：泛型子类

       1. 全部保留：

          class SubClass3<T1,T2> extends<T1,T2>{}

          class SubClass3<T1,T2,A,B> extends<T1,T2>{}

       2. 部分保留：

          class SubClass4<T2> extends SuperClass<Integer,T2> {}

          class SubClass4<T2,A,B> extends SuperClass<Integer,T2> {}

14. 泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系，即泛型方法所属的类是不是泛型不影响泛型方法

    1. 泛型方法的声明：[访问权限] <泛型> 返回类型 方法名([泛型标识 参数名称]) 抛出的异常
    2. 泛型方法在调用时，指明泛型参数的类型；泛型方法可以声明为静态的，泛型参数是在调用方法时确定的，并非在实例化类时确定的

15. 泛型在继承方面的体现：

    1. 类A是类B的父类，G<A>和G<B>二者不具备子父类关系，二者是并列关系
    2. 类A是类B的父类，A<G>是B<G>的父类

16. 通配符的使用：

    1. 通配符：“?”

    2. 类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是G<?>

    3. 读取：List<?>的对象读取list的元素时，永远是安全的，因为不管是liat的真实类型还是什么，它包含的都是Object

    4. 写入：list中的元素不支持写入，因为不知道写入的元素类型，不能像其中添加对象，唯一例外的是null

       import org.junit.Test;
       
       import java.util.*;
       
       /**
        * @Author: xuehai.XUE
        * @MailBox: xuehai.xue@qq.com
        * @Date: 2021/3/25 12:53
        * @Description:
        */
       public class GenericTest {
           @Test
           /** 通配符的使用 */
           public void test4(){
               List<Object> list1 = new ArrayList<>();
               List<String> list2 = new ArrayList<>();
       
               list1.add("123");
               list1.add("456");
               list1.add("789");
       
               list2.add("123");
               list2.add("456");
               list2.add("789");
       
               List<?> list = null;
       
               list = list1;
               list = list2;
       
               print(list1);
               System.out.println("**********");
               print(list2);
       
               List<String> list3 = new ArrayList <>();
               list3.add("123");
               list3.add("456");
               list3.add("789");
               list = list3;
               //添加（写入）：对于List<?>就不能向其内部添加数据，除了添加null之外
       //        list.add("dd");
               list.add(null);
       
               System.out.println("**********");
               //获取（读取）：允许读取数据，读取的数据类型是Object
               Object o = list.get(0);
               System.out.println(o);
           }
       
           private void print(List<?> list) {
               for (Object o : list){
                   //问题解决：使用泛型后，直接避免了强制转换的操作
                   System.out.println(o);
               }
           }
       }
       

    5. 有限制的通配符的使用：

       1. 通配符指定上限：

          上限extends：使用时指定的类型必须是继承某一个类，或者实现某个接口，即<=

          ? extends A：G<? extends A>可以作为G<A>和G<B>的父类。其中B是A的子类

       2. 通配符指定下限：

          下限super：使用时指定的类型不能小于操作的类，即>=

          ? super A：G<? super A>可以作为G<A>和G<B>的父类。其中B是A的父类

       3. 举例：

          <? extends Number>：只允许泛型为Number及Number子类的引用调用 <? super NUmber>：只允许泛型为Number以及Number父类的引用调用 <? extends Comparable>：只允许泛型为实现Comparable接口的实现类的引用调用

A>可以作为G<A>和G<B>的父类。其中B是A的父类

   3. 举例：

      <? extends Number>：只允许泛型为Number及Number子类的引用调用

      <? super NUmber>：只允许泛型为Number以及Number父类的引用调用

      <? extends Comparable>：只允许泛型为实现Comparable接口的实现类的引用调用

[外链图片转存中…(img-lLXH5r6j-1616654991492)]

STAY ANGER!!!