Java JDK1.5： 泛型 新特性的讲解说明
每博一文案
听到过这样一句话：“三观没有标准。在乌鸦的世界里，天鹅也有罪。”
环境、阅历的不同，造就了每个人独有的世界观、人生观、价值观。
三观并无对错高下，只有同与不同。恰如飞鸟不用和游鱼同行，高山不必同流水相逢。
总用自己的尺子去度量别人，无疑是一种狭隘。面对不同时，只有懂得尊重对方，才能跳出固有的认知，看得更高更远。
这个世界上没有标准答案，人不是只有一种活法。
@
- Java JDK1.5： 泛型 新特性的讲解说明
- 每博一文案
- 1. 泛型概述
- 2. 为什么要使用泛型
- 3. 集合中使用泛型
-
4. 自定义泛型结构
- 4.1 输入参数命名约定
- 4.2 自定义泛型结构的接口
-
4.3 自定义泛型结构的类
- 4.3.1 含有泛型的类实例化对象
- 4.4 自定义泛型结构的方法
- 5. 泛型在继承上的体现
-
6. <泛型> 中的 通配符
- 6.1 通配符的使用：注意点
-
6.2 有限制的通配符
- 6.2.1 无界通配符
- 6.2.2 上界通配符
- 6.2.3 下界通配符
- 7. 对泛型的限制(泛型的使用上的注意事项)
- 8. 泛型应用举例
- 9. 总结：
- 10. 最后：
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);
}
}
9. 总结：
- 泛型是 JDK5.0 的新特性。
- Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生
ClassCastException异常。同时，代码更加简洁、健壮。 - 把一个集合中的内容限制为一个特定的数据类型，这就是generics背后的核心思想
- 泛型只能填充引用类型，基本数据类型不可填充泛型，使用包装类。
- 使用泛型的主要优点是能够在编译时而不是在运行时检测错误。
- 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价 于Object。经验： 泛型要使用一路都用。要不用，一路都不要用。
- 自定义泛型类，泛型接口，泛型方法。
- 泛型类在父类上的继承变化上的使用。
- 泛型中的通配符上的使用：无界通配符
<?>，上界通配符< ? extends XXX>(<=)，下界通配符<? super XXX>(>= ) - 泛型在使用上的限制以及注意事项。
10. 最后：
限于自身水平，其中存在的错误，希望大家给予指教，韩信点兵——多多益善。谢谢大家，江湖再见，后会有期！！！
