本部分主要介绍：Java 的泛型、泛型通配符使用的规则和注意事项

泛型总结

1. 泛型是 JDK 1.5 出现的技术，是为了 Java 安全性考虑。泛型即限定类型的使用，将运行时异常提前到编译时异常。
2. 泛型可以在定义类、方法和接口上
   • 类中泛型不能创建对象 T t = new T() ，因为泛型是不确定的类型，即无法开辟空间
   • 接口的泛型不能是成员变量。接口的成员变量的修饰符 public static final 与泛型的使用规则相违背（即不确定类型，如何成为静态常量，为实现类提供规则呢！）
   • 定义泛型可以不使用，不使用时默认是 Obejct 类型
3. 泛型通配符 只适用于方法定义时的 方法的形参 （不是调用方法的传入的实参）以复用代码为目的

泛型出现的目的

1. 泛型的本质

   • 类型参数化，将类型当作参数。
   • 在定义类或集合（当然集合是 Java 自带的）时，不指定元素的明确类型，直到创建对象或集合时，才明确对象或集合中的元素类型。

2. 泛型的好处

   • 限定类型，避免类型转换错误

   • 可以把异常从运行时期提到编译时期

   • 与集合连用，不需要转换类型

     ArrayList<String> list = new ArrayList<String>(); // 泛型完整的写法
     // ArrayList<String> list = new ArrayList(); // 泛型的简化写法
     list.add("ab.c");
     list.get(0).split("\\."); // 可以直接调用 String 方法，不需要转换
     

3. 泛型与 Object 相比，限定类型的使用

   • 集合在明确泛型类型时，默认使用的是 Object 类型，即可以接受 Java 的所有类型。

   • 在 Java 中 Object 类是所有类的父类，Object 可以接受所有类型（8 中基本类型除外）。当向集合添加元素时 向上转型 为 Object 类型，当取出元素时 向下转型，如下，编译器并不会报错，只有在运行时，才会报 CalssCastExecption 异常。

     ArrayList list = new ArrayList(); // 没有指定泛型，实际默认是以 Object 类型接受
     list.add(1); // 编译不会报错
     list.add("abc"); // 编译不会报错
     // 当取出集合元素时，编译并不会报错；运行时报错
     String str = (String) list.get(0);
     String in = (String) list.get(1);
     

   • 而泛型就是将类型做限定（只有在类型限定范围能，才可以使用），将错误提示发生在编译时期（这也是 Java 一直在做的，将运行时期错误，提到编译时期）。如下，泛型限定 String ，向其添加 Integer 编译时期就会报错。

     ArrayList<String> list = new ArrayList<String>();
     list.add(1); //编译时期，直接提示错误，这样对集合就做了类型的限定
     

泛型的注意事项

1. 泛型格式

   • 数据类型<泛型的类型> 对象 = new 数据类型<泛型的类型>();

   • 泛型一般与集合连用较多，正常书写方法（等号两边的泛型如果写，就必须保持一致）

     ArrayList<String> list = new ArrayList<String>();
     

   • 简化写法（jdk 1.7 出现的特性，依据右侧推测左侧的类型）

     ArrayList<String> list = new ArrayList();
     

   • 介绍泛型以下几种写法（与集合连用）

     1. 泛型推断，等号左边写泛型，右边可以不写泛型。等号左边是完整的泛型定义，可以从左边推断出右边的泛型类型，集合只能添加 String 类型

        ArrayList<String> list = new ArrayList<>();
        list.add("abc"); //正确
        list.add(new Integer(1)); // 错误
        

     2. 等号右边写泛型，左边不写。这样就如同没有泛型，任何类型都可以添加。

        ArrayList list = new ArrayList<String>();
        list.add("abc"); // 正确
        list.add(new Integer(1)); // 正确
        

2. 通配符注意

   • 泛型通配符 不适用 于集合对象的创建
   • 泛型通配符 适用 于方法的形参上

泛型类、方法、接口

1. 泛型类

   • 泛型类定义

     public class GenericType<T> {
         // <T> 就是形参
         //也可以定义多个泛型 <T, E>
         T t;
     }
     

   • 类中的泛型，不能创建对象 T t = new T() 。可以这样理解：泛型是参数化类型，类中的泛型就是参数，在没有明确实参的情况，泛型怎么可以创建对象呢！。

   • 实例化对象时，在没有明确泛型类型时，泛型类型默认为 Object

2. 泛型接口

   • 泛型接口定义

     public interface GenericInter<T, E> {
         // <T> 就是形参
         //也可以定义多个泛型 <T, E>
         //T t; // 错误
         public abstract void method1(T t);
         public abstract void method2(E e);
     }
     

   • 泛型接口不可以定义成员变量 T t; 。可以这样理解：接口的成员都是 public static final 修饰的，这是接口的特性（提供规则，子类必须遵循，不可以更改）。泛型接口，泛型没有明确类型时，就不能向子类提供规则。相反，则违背了接口的规则。

   • 泛型接口，只会体现在接口的方法中

     public abstract void method(T t);
     

   • 实现接口的 3 中方式

     1. 实现接口时，无泛型，默认使用 Object 类型

        public class GenericType implements GenericInter {
        
            @Override
            public void method1(Object t) {
            }
        
            @Override
            public void method2(Object e) {
            }
        }
        

     2. 实现接口时，实现类使用泛型，但未明确泛型类型时，实现类与接口的泛型必须保持一致（此类称之为泛型类）

        public class GenericType<T, E> implements GenericInter<T, E> {
        
            @Override
            public void method1(E t) {
            }
        
            @Override
            public void method2(T e) {
            }
        }
        

     3. 实现接口时，就明确类型

        public class GenericType implements GenericInter<String, Integer> {
        
            @Override
            public void method1(Integer t) {
            }
        
            @Override
            public void method2(String e) {
            } 
        }
        

3. 泛型方法

   • 泛型方法定义，泛型定义在方法的返回类型前面

     class GenericMethod {
         public <T> void method(T t) {  
         }
     }
     

   • 泛型方法使用

     GenericMethod g = new GenericMethod();
     g.method("abc"); // 调用方法时，传入泛型确定类型
     

泛型通配符

1. 通配符的种类

   • ? 任意类型，没有明确那就是 Object 以及任意的 Java 类型
   • ? extends E 向下限定，E 及其子类
   • ? super E 向上限定，E 及其父类

2. 通配符使用场景

   • 通配符的使用场景是方法的 形参上 ，表示方法可以接受的数据类型

     public void method(ArrayList<? extends People> list) {
         
     }
     

   • 泛型通配符不是用在对象定义上

     1. 如集合

        // 语法报错
        ArrayList<?> list = new ArrayList<?>();
        ArrayList<? extends People> list = new ArrayList<? entends People>();
        ArrayList<? super Student> list = new ArrayList<? super Student>();
        
        // 任何元素都添加不上，除了 null
        ArrayList<?> list = new ArrayList<>();
        // 任何元素都添加不上，除了 null
        ArrayList<? extends People> list = new ArrayList<>();
        // 可以添加 Student以及子类
        ArrayList<? super Student> list = new ArrayList<>();
        

     2. 在类上使用、在接口上使用、在调用方法时，都会发生语法错误

3. 通配符出现的原因

   • 数组有协变，集合没有协变

   • 协变

     1. Student extends People ，那么 Peole[] 兼容 Studnet[]。

     2. 集合使用泛型之后是不能协变，ArrayList<People> 不是 ArrayList<Student> 父类，当然也不可以兼容的

     3. 集合想要兼容，通配符解决了这个问题。Student 和 People 都可以当此方法的实参

        public void method(ArrayList<? extends People> list) {
            
        }
        

   • 问题的提出

     1. 定义 两个类， Student 类继承 People 类

     2. 定义两个数组和两个集合

        Student[] stu = new Studnet[2];
        People[] p = new Peoplep[2];
        
        ArrayList<People> list = new ArrayList<People>();
        ArrayList<Student> list1 = new ArrayList<>();
        

     3. 定义两个方法

        public void method1(People[] people){
            
        }
        
        public void method2(List<People> liat) {
            
        }
        

     4. 调用两个方法

        method1(p);
        method1(stu); // 类型兼容
        
        method2(list);
        method2(list1); // 类型不兼容
        

   • 解决办法

     1. 通配符的出现

        • 修改 method2 方法，表示 People 及其子类都兼容

          public void method2(List<? extends People> liat) {
              
          }