Java JDK1.5：泛型新特性的讲解说明

技术分享 3年前 (2023-02-06) 0 999+

Java JDK1.5：泛型新特性的讲解说明

每博一文案

听到过这样一句话：“三观没有标准。在乌鸦的世界里，天鹅也有罪。” 环境、阅历的不同，造就了每个人独有的世界观、人生观、价值观。 三观并无对错高下，只有同与不同。恰如飞鸟不用和游鱼同行，高山不必同流水相逢。 总用自己的尺子去度量别人，无疑是一种狭隘。面对不同时，只有懂得尊重对方，才能跳出固有的认知，看得更高更远。 这个世界上没有标准答案，人不是只有一种活法。

1. 泛型概述

在任何不重要的软件项目中，错误都只是生活中的事实。仔细的计划，编程和测试可以帮助减少他们的普遍性，但不知何故，在某个地方，他们总是会找到一种方法来进入你的代码。随着新功能的推出以及您的代码库规模和复杂性的增加，这一点变得尤为明显。

幸运的是，一些错误比其他错误更容易被发现。例如，编译时错误可以在早期发现; 你可以使用编译器的错误信息来找出问题所在，然后修正它。运行时错误，然而，可能是更多的问题; 它们并不总是立即出现，而且当它们这样做时，它可能在程序中的某一点远离问题的实际原因。

泛型通过在编译时检测更多的错误来增加代码的稳定性。

泛型的设计背景

集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为 Object，JDK1.5 之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection，List，ArrayList 这个就是类型参数，即泛型。

泛型的概述
- 所谓的泛型，就是允许在定义类，接口时通过一个标识<T>类中某个属性的类型或者时某个方法的返回值以及参数类型。或者换句话说：就是限定类/接口/方法(参数/返回值)的类型。特别的就是限定集合中存储的数据类型。这个类型参数将在使用时(例如：继承或实现这个接口，用这个类型声明变量，创建对象时) 确定(即传入实际的类型参数，也称为 “类型实参”)。
- 从 JDK1.5 以后，java 引入了 “参数化类型 (Parameterized type)” 的概念，允许我们在创建集合时再指定集合元素的类型，正如： List<String> ，这表明该 List 集合只能存储 字符串String类型的对象 。
- JDK1.5 改写了集合框架中全部接口和类，为这些接口，类增加了泛型支持，从而可以在声明集合变量，创建集合对象时传入类型实参。

2. 为什么要使用泛型

那么为什么要有泛型呢，直接Object 不是也可以存储数据吗？

解决元素存储的安全性问题，好比商品，药品标签，不会弄错
解决获取数据元素时，需要类型强制转换的问题，好比不用每回拿药，药品都要辨别，是否拿错误。

如下举例：

没有使用泛型

我们创建一个 ArrayList 集合不使用泛型，默认存储的是 Object 类型，用来存储学生的成绩 int 类型，添加成绩时不小心添加了

学生的姓名，因为该集合没有使用泛型，默认是Object 类型，什么都可以存储，所以也把这个输入错误的学生姓名给存储进去了。

当我们把 ArrayList 集合当中的存储的数据取出 (强制转换为 int 类型的数据成绩时)，报异常：java.lang.ClassCastException 类型转换异常。因为你其中集合当中存储了一个学生的姓名，String 是无法强制转换成 int 类型的。

 import java.util.ArrayList;  public class GenericTest {     // 没有使用泛型     public static void main(String[] args) {         // 定义了泛型没有使用的话，默认是 Object 类型存储         ArrayList arrayList = new ArrayList();          // 添加成绩         arrayList.add(99);         arrayList.add(89);         arrayList.add(79);          // 问题一:存储的类型不安全         // 不小心添加了一个学生的姓名         arrayList.add("Tom");          for (Object o : arrayList) {             // 问题二: 强转时，可能出现ClassCastException 异常             int stuScore = (Integer)o;  // 因为你存储的类型可能与强制转换的类型，没有继承关键，实例关系             // 导致转换失败.             System.out.println(stuScore);         }     } }

使用了泛型

将 ArrayLsit 集合定义为 ArrayList<Integer> 使用上泛型，限定了该集合只能存储 Integer 类型的数据，其它类型的无法存入进到集合当中，编译的时候就会报错。

import java.util.ArrayList;  public class GenericTest {     // 使用上泛型     public static void main(String[] args) {         // 泛型限定了存储类型，泛型指定定义引用类型，基本数据类型不行         ArrayList<Integer> arrayList = new ArrayList<Integer>();         // 使用了泛型: 就会进行类型检查，保证数据的安全         arrayList.add(99);  // 包装类，自动装箱         arrayList.add(78);         arrayList.add(76);         arrayList.add(89);         arrayList.add(88);          // arrayList.add("Tom"); // 存储不符合泛型的数据，编译无法通过。         for (Integer integer : arrayList) {             int stuScore = integer;  // 不需要强制转换自动拆箱              System.out.println(stuScore);         }     }  }

Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生 java.lang.ClassCastException异常。同时代码更加简洁，健壮 。

简而言之，在定义类，接口和方法时，泛型使类型（类和接口）成为参数。就像方法声明中使用的更熟悉的 形式参数 一样，类型参数为您提供了一种方法，让您在不同的输入中重用相同的代码。区别在于形式参数的输入是值，而类型参数的输入是类型。

使用泛型的代码比非泛型代码有许多优点：

编译时更强大的类型检查。

Java 编译器将强类型检查应用于通用代码，并在代码违反类型安全性时发出错误。修复编译时错误比修复运行时错误要容易得多。
消除强制转换。

3. 集合中使用泛型

在 Java SE 7 和更高版本中，只要编译器可以根据上下文确定或推断类型参数，就可以用一组空类型参数（<>）替换调用泛型类的构造函数所需的类型参数。这一对尖括号，<>，非正式地称为钻石。例如，您可以使用以下语句创建 Box <Integer> 的实例：

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

在 List集合中使用泛型，存取数据

  import java.util.ArrayList; import java.util.Iterator; import java.util.List;  public class GenericTest2 {     // List 集合中使用泛型存取数据     public static void main(String[] args) {         // 使用泛型<String> 限定 List 集合存储的类型对象，         // 注意：泛型中只能存储引用类型的，基本数据类型不可以(int,double)         List<String> list = new ArrayList<>();          list.add("Tom");         list.add("李华");         list.add("张三");          Iterator<String> iterator = list.iterator();          while(iterator.hasNext()) {             String s = iterator.next();             System.out.println(s);         }      } }

在Set集合中使用泛型，存取数据

import java.util.HashSet; import java.util.Iterator; import java.util.Set;  public class GenericTest2 {     public static void main(String[] args) {         // Set 集合中使用泛型存取数据         // 使用泛型<Integer> 限定Set 集合存储的类型对象         // 注意：泛型中只能存储引用类型的，基本数据类型不可以(int,double)         Set<Integer> set = new HashSet<>();          set.add(1);         set.add(2);         set.add(3);          Iterator<Integer> iterator = set.iterator();         while(iterator.hasNext()) {             Integer next = iterator.next();             System.out.println(next);         }     }

在 Map 集合中使用泛型存取数据

 import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set;  public class GenericTest2 {     // Map 集合中使用泛型存取数据     public static void main(String[] args) {         // 使用泛型<String,Integer> 限定 Map 集合存储的类型对象         // 注意：泛型中只能存储引用类型的，基本数据类型不可以(int,double)          Map<String, Integer> map = new HashMap<>();         map.put("Tom", 99);         map.put("李华", 89);         map.put("张三", 79);          Set<Map.Entry<String, Integer>> entries = map.entrySet();         Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();         while (iterator.hasNext()) {             Map.Entry<String, Integer> entry = iterator.next();             System.out.println(entry.getKey() + "--->" + entry.getValue());          }     } }

泛型是可以被嵌套的，多层嵌套泛型Set<Map.Entry<T>>

Set<Map.Entry<String, Integer>> entries = map.entrySet(); Iterator<Map.Entry<String, Integer>> iterator = entries.iterator(); // 这里泛型嵌套了两层: Set<Map.Entry<>> 这是一层 //      内部还有一层: Map.Entry<String,Integer> 这是第二层

4. 自定义泛型结构

4.1 输入参数命名约定

按照惯例，类型参数名称是单个大写字母。这与你已经知道的变量命名约定形成了鲜明的对比，并且有很好的理由：没有这个约定，很难区分类型变量和普通类或接口名称。

最常用的类型参数名称是：

E - 元素（由 Java 集合框架广泛使用）
K - Key
N - Number
T - Type
V - Value
S,U,V etc. - 2nd, 3rd, 4th types

4.2 自定义泛型结构的接口

一个泛型接口的定义格式如下：

接口中的泛型可以定义一个，也可以定义多个，多个泛型 T 使用逗号, 分隔开来。

public interface MyGeneric<T1, T2, ..., Tn> { }

接口中的泛型 T ，可以在抽象方法中应用起来：

在抽象方法中作为方法值 T

public interface MyGeneric<T> {      // 定义含有泛型的 T 抽象方法：泛型作为返回值;     public T fun(); }

在抽象方法中作为参数 T

public interface MyGeneric<T> {     // 定义含有泛型的 T 抽象方法： 泛型作为参数     public void fun2(T t);  }

既作为抽象方法中的返回值 T ，又作为抽象方法中的参数 T

public interface MyGeneric<T> {          // 定义含有泛型的 T 抽象方法： T 泛型作为返回值，参数     public T fun3(T t);  }

public interface MyGeneric<T> {      // 定义含有泛型的 T 抽象方法：泛型作为返回值;     public T fun();      // 定义含有泛型的 T 抽象方法： 泛型作为参数     public void fun2(T t);      // 定义含有泛型的 T 抽象方法： T 泛型作为返回值，参数     public T fun3(T t);  }

4.3 自定义泛型结构的类

一个泛型类的定义格式如下：

class name<T1, T2, ..., Tn> { /* ... */ }

由尖括号（<>）分隔的类型参数部分在类名后面。它指定了类型参数（也称为类型变量）T1，T2，...，和Tn。

要更新 Box 类以使用泛型，可以通过将代码 public class Box 更改为 public class Box <T> 来创建泛型类型声明。这引入了类型变量 T，可以在类中的任何地方(非静态方法，属性，参数，返回值)使用。

把一个集合中的内容限制为一个特定的数据类型，这就是泛型背后的核心思想。

注意：含有泛型的类的构造器的创建，和没有使用泛型一样创建构造器，就可以了，不要附加你的奇思妙想

如下：

public class Box<T> {          // 泛型<T> 应用类属性当中     T t;           // 无参构造器     public Box() {              }          // 带泛型参数构造器     public Box(T t) {         this.t = t;     } }

具体如下代码

 public class Box<T> {      // 泛型<T> 应用类属性当中     T t;       // 无参构造器     public Box() {      }      // 带泛型参数构造器     public Box(T t) {         this.t = t;     }       // 泛型<T> 应用到方法返回值中     public T fun() {        return null;     }      // 泛型<T> 应用到参数当中     public void fun2(T t) {      }      // 泛型<T> 应用到返回值，参数当中     public T set(T t) {         return null;     }   }

注意异常类中不可以使用泛型<T> 编译无法通过

不可以使用泛型创建数组，编译无法通过

但是我们可以用，特殊方法实现如下：通过创建一个 new Object[] 的数组，再强制转换为 T[] 泛型数组,因为泛型默认没有使用的话，是 Object 类型。

泛型不可以作为实例化对象出现，因为泛型是在实例化的时候才确定该泛型具体的类型是什么的，如果直接对泛型实例化，你都不知道实例化成什么类型的对象的。所以直接编译无法通过。

如下：

4.3.1 含有泛型的类实例化对象

带有泛型的实例化：一定要在类名/接口后面指定类型参数的值(类型)。如下:

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

**JDK 7 ** 版本以后可以省略 = 等号右边的 <>泛型声明了，只要声明左边的就可以了。就算你右边附加上了<>泛型声明，默认也是会被省略的。

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

注意泛型和集合一样，只能存储引用类型的数据，泛型不能用基本数据类型填充，必须使用引用类型填充，这里包装类就起到了非常重要的作用了。

4.4 自定义泛型结构的方法

泛型方法 是引入自己的类型参数的方法。这与声明泛型类型相似，但是类型参数的作用域仅限于声明它的方法。允许使用静态和非静态泛型方法，以及泛型类构造函数。

泛型方法的语法包括一个类型参数列表，里面的尖括号出现在方法的返回类型之前。对于静态泛型方法，类型参数部分必须出现在方法的返回类型之前。

泛型方法，与该类是不是含有泛型类无关 ，换句话说：泛型方法所属的类是不是泛型类都没有关系，同样可以定义泛型方法。

定义非静态泛型方法格式如下：

访问权限修饰符 <泛型>(表示泛型方法不可省略) 返回类型 方法名(参数类型 参数名) 抛出的异常

public <E> E fun3(E e) {     return e; }

定义静态泛型方法格式如下：在附加上一个 static 静态修饰，

访问权限修饰符 static  <泛型>(表示泛型方法不可省略) 返回类型 方法名(参数类型 参数名) 抛出的异常

public static <E> E fun4(E e) {         System.out.println("静态：泛型方法，泛型作为返回值，参数"+e);         return e; }

 package blogs.blog8;  public class GenericTest4 {     public static void main(String[] args) {         // 泛型方法的调用:       }  }  class MyClass {      // 泛型方法，无返回值的     public <E> void fun() {         System.out.println("泛型方法，无返回值,无参数的");     }      // 泛型方法: 泛型作为参数传入     public <E> void fun2(E e) {         System.out.println("泛型方法，无返回值，有泛型参数"+e);     }      // 泛型方法: 泛型作为返回值，和参数     public <E> E fun3(E e) {         System.out.println("泛型方法，泛型作为返回值，参数"+e);         return e;     }      public static <E> E fun4(E e) {         System.out.println("静态：泛型方法，泛型作为返回值，参数"+e);         return e;     } }

泛型方法的调用和没有普通的方法一样的方式调用，没有什么区别，区别是在 JVM 运行编译的时候的不同。调用是一样的方法如下

package blogs.blog8;    public class GenericTest4 {     public static void main(String[] args) {         // 泛型方法的调用:         MyClass myClass = new MyClass();         myClass.fun();         myClass.fun2(new String("Hello"));         String s = myClass.fun3("你好世界");         System.out.println(s);          System.out.println("**********");         String s2 = MyClass.fun4("Hello Wrold");         System.out.println(s2);       }  }  class MyClass {      // 泛型方法，无返回值的     public <E> void fun() {         System.out.println("泛型方法，无返回值,无参数的");     }      // 泛型方法: 泛型作为参数传入     public <E> void fun2(E e) {         System.out.println("泛型方法，无返回值，有泛型参数"+e);     }      // 泛型方法: 泛型作为返回值，和参数     public <E> E fun3(E e) {         System.out.println("泛型方法，泛型作为返回值，参数"+e);         return e;     }      public static <E> E fun4(E e) {         System.out.println("静态：泛型方法，泛型作为返回值，参数"+e);         return e;     } }

泛型方法在你调用的时候，就会推断出你要 <E> 泛型的具体的类型了。 如下：

5. 泛型在继承上的体现

关于父类中含有泛型<> 对应的子类的对父类泛型的处理情况：如下

父类有泛型，子类继承父类：不保留父类中的泛型，擦除了父类中的泛型(默认是 Object)

// 父类 class Father<T1,T2> {  }   // 子类没有保留父类的泛型，擦除了: 等价于class Son extends Father<Object,Object>{} class Son1 extends Father{  }

父类有泛型，子类继承父类：并指明了父类的泛型(具体类型)

注意: 由于子类在继承泛型的父类/实现的接口时，指明了泛型具体是什么类型，所以实例化子类对象时，不再需要指明泛型了。

但是单独实例化父类还是要指明其泛型的具体类型的。

// 父类 class Father<T1,T2> {  }  // 子类保留了父类的泛型，并指明了父类中泛型的具体类型 class Son2 extends Father<String,Integer> {      }

父类有泛型，子类继承父类：并保留了父类的泛型(并没有指明具体类型)

注意: 因为子类并没有指明父类泛型的具体类型，所以子类要沿用上父类的泛型<>从而对父类上的泛型(赋予具体类型),不然编译无法通过。

// 父类 class Father<T1,T2> {  }  // 子类保留了父类的泛型，并没有指明父类的具体类型 // 注意：因为没有指明父类泛型的具体类型，所以子类要沿用上父类的泛型<>从而对父类上的泛型(赋予具体类型) class Son3<T1,T2> extends Father<T1,T2> {  }

父类有泛型，子类继承父类：并保留了父类的泛型(并没有指明具体类型)，外加子类定义自己独有的泛型

注意: 因为子类并没有指明父类泛型的具体类型，所以子类要沿用上父类的泛型<>从而对父类上的泛型(赋予具体类型),不然编译无法通过。

// 父类 class Father<T1,T2> {  }  // 子类继承父类：并保留了父类的泛型(并没有指明具体类型)，外加子类定义自己独有的泛型 class Son4<T1,T2,E,E2> extends Father<T1,T2> {      }

父类有泛型，子类继承父类：并保留了父类的部分泛型(部分指明了父类的泛型具体类型，部分没有指明父类的泛型具体类型)，外加子类定义自己独有的泛型

注意: 因为子类并没有指明父类泛型的具体类型，所以子类要沿用上父类的泛型<>从而对父类上的泛型(赋予具体类型),不然编译无法通过。

// 父类 class Father<T1,T2> {  }  // 父类有泛型，子类继承父类：并保留了父类的`部分`泛型(部分指明了父类的泛型具体类型，部分没有指明父类的泛型具体类型)，外加子类定义自己独有的泛型 class Son4K<T2,E,E2> extends Father<String,T2> {      }

6. <泛型> 中的通配符

泛型的多态性上的使用

注意: ArrayList<String> 和 ArrqayList<Intger> 是两种不同的类型，虽然它们整体上是都是 ArrayList 集合类，但是所指定的泛型(指明的类型不同，导致存储的类型不同) ，编译时被鉴定为了两种不同的类型，无法相互引用赋值。但是，在运行时只有一个 ArrayList 被加载到 JVM 中，因为类一样的，所存储的类型不同而已，类仅仅只会加载一次到i内存当中。
简单的说：就是泛型不同的不可以相互引用赋值 ，编译无法通过。

如下代码：

两个泛型相同的类型可以引用赋值如下

根据上述情况，我们对不同的泛型(具体指明的类型) 需要定义不同的方法了。注意: 如果是的泛型<指明的具体类型>不同是无法重载方法的。

import java.util.ArrayList; import java.util.List;  public class GenericTest6 {     public static void main(String[] args) {         ArrayList<String> arrayList = new ArrayList<>();         ArrayList<Integer> arrayList2 = new ArrayList<>();                  fun1(arrayList);  // <String>         fun2(arrayList2); // <Integer>     }       public static void fun1(List<String> list) {      }      public static void fun2(List<Integer> list) {      } }

为了解决上述，因为泛型(指明的具体类型)的不同，而导致的繁琐操作。Java为程序员提供了 通配符?

在泛型代码中，被称为通配符的是 一个问号（?） 表示未知类型。通配符可用于多种情况：作为参数的类型、字段或局部变量;

有时作为返回类型（尽管更好的编程实践更具体）。比如：List ，Map 。List<?> 可以理解为是Lis<String>t、List<Object>等各种泛型List的父类。

通配符永远不会用作泛型方法调用，泛型类实例创建或超类型的类型参数。

举例:

import java.util.ArrayList; import java.util.List;  public class GenericTest6 {     public static void main(String[] args) {         ArrayList<String> arrayList = new ArrayList<>();         ArrayList<Integer> arrayList2 = new ArrayList<>();         ArrayList<?> arrayList3 = new ArrayList<>();         arrayList3 = arrayList;  // 尽管 <String> 不同，都可以赋值给 <?> 通配符         arrayList3 = arrayList2; // 尽管 <Integer> 不同，都可以赋值给 <?> 通配符     } }

举例:

import java.util.ArrayList; import java.util.List;  public class GenericTest6 {     public static void main(String[] args) {         ArrayList<String> arrayList = new ArrayList<>();         ArrayList<Integer> arrayList2 = new ArrayList<>();          fun(arrayList);  // <String>         fun(arrayList2); // <Integer>     }      public static void fun(List<?> list) {      } }

对于 List<?>，Map<?,?>，Set<?> 等等对象读取(添加)数据元素时，永远时可以添加成功的，因为不管 list<泛型> 中的泛型具体指明的是什么类型都，它们都是包含了 Object ，都可以被 ? 接受住。

我们可以调用 get() 方法并使用其返回值。返回值是一个未知的类型，但是我们知道，它总是一个Object。

如下代码:

import java.util.ArrayList; import java.util.List;  public class GenericTest6 {     public static void main(String[] args) {         List<?> list3 = null;         List<String> list = new ArrayList<>();         list.add("Hello");         list.add("World");          // 将 List<String> 引用赋值给 List<?>         list3 = list;         // 获取值         Object o = list3.get(0);         System.out.println(o);         Object o2 = list3.get(1);         System.out.println(o2);          System.out.println("*******************************");          List<Integer> list2 = new ArrayList<>();         list2.add(99);         list2.add(999);          // 将 List<Integer> 引用赋值给 List<?>         list3 = list2;         // 获取值         Object o3 = list3.get(0);         System.out.println(o3);         Object o4 = list3.get(1);         System.out.println(o4);       } }

对于 List<?>，Map<?,?>，Set<?> 等等对象读取(添加)数据元素时，报编译无法通过。因为我们不知道 ？的元素类型，我们不能向其中添加对象。唯一的例外是null，它是所有类型的成员。

将任意元素加入到其中不是类型安全的：

Collection c = new ArrayList();

c.add(new Object()); // 编译时错误

因为我们不知道c的元素类型，我们不能向其中添加对象。add方法有类型参数E作为集合的元素类型。我们传给add的任何参数都必须是一个未知类型的子类。因为我们不知道那是什么类型，所以我们无法传任何东西进去。

举例:

6.1 通配符的使用：注意点

注意点1：编译错误：通配符不能用在泛型方法声明上，返回值类型前面也<>不能使用。

注意点2：编译错误：通配符不能用在泛型类的声明上。

注意点3：编译错误：不能用在创建对象上，右边属于创建集合对象。

6.2 有限制的通配符

6.2.1 无界通配符

<?> 允许所以泛型的引用调用。称为 无界通配符 。上面介绍了，就这里就不多介绍了。

6.2.2 上界通配符

< ? extends XXX> 上限 extends ：使用时指定的类型必须是继承某个类(XXX)，或者实现了某个接口(X

xX)。即 <= 。

比如:

< ? extends Person>;  // (无穷小, Person] 只允许泛型为 Person 以及 Person 子类的引用调用 < ? extends Comparable>;  // 只允许泛型为实现 Comparable 接口的实现类的引用调用

举例:

package blogs.blog8;  import java.util.ArrayList; import java.util.List;  public class GenericTest7 {     public static void main(String[] args) {         List< ? extends Person> list = null;  // <=         List<Person> list2 = new ArrayList<>();         List<Student> list3 = new ArrayList<>();         List<Object> list4 = new ArrayList<>();          // list 可以存取 <= Person 的类型         list = list2;         list = list3;         list = list4; // 这就Object > Person 不行      } }   class Person {  }  class Student extends Person {  }

注意：同样 <? extends XXX> 下界通配符，的引用不可以添加数据(因为是未知的类型)，但是可以获取起其中的数据，返回 XXX 最大的。

“写入” 添加数据，无法写入

"读"：获取数据: 返回对应最大的 XXX

package blogs.blog8;  import java.util.ArrayList; import java.util.List;  public class GenericTest7 {     public static void main(String[] args) {         List< ? extends Person> list = null;  // <=         List<Person> list2 = new ArrayList<>();         List<Student> list3 = new ArrayList<>();         List<Object> list4 = new ArrayList<>();         list3.add(new Student() );          // list 可以存取 <= Person 的类型         list = list2;         list = list3;          // 获取数据 “读”         Person person = list.get(0);         System.out.println(person);      } }   class Person {  }  class Student extends Person {  }

6.2.3 下界通配符

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

比如:

< ? super Person>;  // [Person, 无穷大] 只允许泛型为 Person 及  Person父类的引用调用

举例:

注意：同样 <? superXXX> 上界通配符，的引用不可以添加数据(因为是未知的类型)，但是可以获取起其中的数据，返回 XXX 最大的。

“写入” 添加数据，无法写入

"读"：获取数据: 返回对应最大的 Object

package blogs.blog8;  import java.util.ArrayList; import java.util.List;  public class GenericTest7 {     public static void main(String[] args) {         List< ? super Person> list = null;  // >= Person         List<Person> list2 = new ArrayList<>();         List<Student> list3 = new ArrayList<>();         List<Object> list4 = new ArrayList<>();         list3.add(new Student() );          // list 可以存取 >= Person 的类型         list = list2;         list = list4;         list.add(new Person());  // 小于的可以添加上         list.add(new Student());          Object object = list.get(0);         System.out.println(object);       }   }   class Person {  }  class Student extends Person {  }

7. 对泛型的限制(泛型的使用上的注意事项)

要有效地使用 Java 泛型，您必须考虑以下限制：

注意：泛型不能只能填充引用类型，不可填充基本数据类型。使用包装类

注意：泛型不可以无法创建类型参数的实例 E new () 不可以 编译无法通过

注意：不能声明类型是类型参数的静态字段/静态方法中(编译无法通过)，但是可以创建静态泛型方法。 因为泛型是实例化对象的时候才确定其指明具体类型，而静态是在实例化之前的操作。静态泛型方法是：在调用静态泛型方法的时候泛型才确定指明具体类型的。所以没问题。

注意：不能使用带有参数化类型的 cast 或 instanceof

注意：泛型不能创建参数化类型的数组

但是我们可以用，特殊方法实现如下：通过创建一个 new Object[] 的数组，再强制转换为 T[] 泛型数组,因为泛型默认没有使用的话，是 Object 类型。

注意：泛型可以用于创建，捕捉或抛出参数化类型的对象自定义异常类中不可以用泛型类

不能重载每个过载的形式参数类型擦除到相同的原始类型的方法，简单的说：就是不能通过指明的泛型的不同实现重载的，不满足重载的要求的

8. 泛型应用举例

定义个泛型类 DAO，在其中定义一个 Map 成员变量，Map 的键为 String 类型，值为 T 类型。

分别创建以下方法：

public void save(String id,T entity)：保存 T 类型的对象到 Map 成员变量中。

public T get(String id)：从 map 中获取 id 对应的对象。

public void update(String id,T entity)：替换 map 中 key 为 id 的内容,改为 entity 对象。

public List list()：返回 map 中存放的所有 T 对象。

public void delete(String id)：删除指定 id 对象。

定义一个 User 类：

该类包含：private 成员变量（int 类型） id，age；（String 类型）name。

定义一个测试类：

创建 DAO 类的对象，分别调用其 save、get、update、list、delete 方法来操作 User 对象，

使用 Junit 单元测试类进行测试。

DAO类，和 User类

package blogs.blog8;   import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Objects;   public class DAO<T> {     private Map<String, T> map = null;      public DAO() {         // 构造器为其Map集合初始化         this.map = new HashMap<>();     }      // 保存 T 类型的对象到Map成员变量中     public void save(String id, T entity) {         map.put(id, entity);     }      // 从map中获取id对应的对象     public T get(String id) {         return map.get(id);     }      // 替换Map中的 key 为 id 的内容，改为 entity对象     public void update(String id, T entity) {         if (map.containsKey(id)) {  // 首先判断该修改的 key 是否存在，             // 存在通过 put()添加覆盖             map.put(id, entity);         }     }      // 返回map中存放的所以 T 对象     public List<T> list() {         Collection<T> values = map.values();         List<T> list = new ArrayList<T>();         // 注意了: Collection 是 List 的父类接口，如果List 对象不是 Collection 的实例         // 是无法将一个父类强制(向下)为子类的，(这里两个都是接口，不可能有实例的)         // 通过取出所以的values 值赋值到一个新创建的 List 对象当中再返回。         for (T t : values) {             list.add(t);         }         return list;      }      // 删除指定id对象     public void delete(String id) {         map.remove(id);     } }  class User {     private int id;     private int age;     private String name;      public User() {      }      public User(int id, int age, String name) {         this.id = id;         this.age = age;         this.name = name;     }      public int getId() {         return id;     }      public void setId(int id) {         this.id = id;     }      public int getAge() {         return age;     }      public void setAge(int age) {         this.age = age;     }      public String getName() {         return name;     }      public void setName(String name) {         this.name = name;     }      // 因为存储的是在Map当中所以，Map当中的Key 存储对象需要重写 equals() 和 hashCode() 方法     @Override     public boolean equals(Object o) {         if (this == o) return true;         if (!(o instanceof User)) return false;         User user = (User) o;         return getId() == user.getId() &&                 getAge() == user.getAge() &&                 Objects.equals(getName(), user.getName());     }      @Override     public int hashCode() {         return Objects.hash(getId(), getAge(), getName());     }      @Override     public String toString() {         return "User{" +                 "id=" + id +                 ", age=" + age +                 ", name='" + name + ''' +                 '}';     } }

DAOTest

package blogs.blog8;  import day25.DAOS; import org.junit.Test;  import java.util.List;  public class DAOTest {     @Test     public void test() {         DAOS<User> dao = new DAOS<User>();          dao.save("1001",new User(1001,34,"周杰伦"));         dao.save("1002",new User(1002,20,"昆菱"));         dao.save("1003",new User(1003,25,"蔡依林"));          dao.update("1003",new User(1003,30,"万文山"));          dao.delete("1002");          List<User> list = dao.list();         list.forEach(System.out::println);       } }