五、泛型
-
泛型的设计背景
集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来 解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时**把元素的类型设计成一个参数，这个类型参数叫做泛型。**Collection，List，ArrayList 这个就 是类型参数，即泛型。
-
所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类 型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如， 继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实 际的类型参数，也称为类型实参）。
-
从JDK1.5以后，Java引入了“参数化类型（Parameterized type）”的概念， 允许我们在创建集合时再指定集合元素的类型，正如：List，这表明 该List只能保存字符串类型的对象。
-
JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持， 从而可以在声明集合变量、创建集合对象时传入类型实参。
5.1 在集合中使用泛型
-
1.泛型的声明
interface List 和 class GenTest 其中，T,K,V不代表值，而是表示类型。这里使用任意字母都可以。 常用T表示，是Type的缩写。
-
2.泛型的实例化：
一定要在类名后面指定类型参数的值（类型）。
如： **List strList = new ArrayList<>(); **
Iterator iterator = customers.iterator();
T只能是类，不能用基本数据类型填充。但可以使用包装类填充
把一个集合中的内容限制为一个特定的数据类型，这就是generics背后 的核心思想
package study.javaSenior.generic;
import org.junit.Test;
import java.util.*;
/**
* 泛型的使用
* 1.jdk5.0新增的特性
*
* 2.在集合中使用泛型
* 总结：
* ①集合接口或者集合类在jdk5.0时都修改为带泛型的结构
* ②在实例化集合类时，可以指定具体的泛型类型
* ③指明完义后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法，构造器，属性等）使用到类的泛型的位置，都指定为实例化的泛型类型。
* 比如：add(E e) ---->实例化以后：add(Integer e)
* ④注意点：泛型类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换
* 比如：int用Integer替换
* ⑤如果实例化时，没有指明泛型的类型（没用泛型），默认类型为Object类型。
*
* @author zhengxu
* @create 2021-06-30 16:30
*/
public class GenericTest {
//在集合中使用泛型之前的情况
@Test
public void test(){
ArrayList list = new ArrayList();
//需求：放学生成绩
list.add(78);
list.add(76);
list.add(98);
list.add(88);
//问题一：类型不安全,分数都是int类型
list.add("Tom");
for (Object score:list){
//问题二：强转时可能出现ClassCastException
int stuScore=(Integer)score;
System.out.println(stuScore);
}
}
//在集合中使用泛型以后
@Test
public void test01(){
ArrayList<Integer> list = new ArrayList<Integer>();//不能使用基本数据类型，要使用它的包装类
//需求：放学生成绩
list.add(78);
list.add(76);
list.add(98);
list.add(88);
//编译时，就会进行类型检测，保证数据安全
// list.add("Tom");//无法添加
//方式一：
for(Integer score:list){
int stuScore=score;
System.out.println(score);
}
//方式二：
Iterator<Integer> iterator=list.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
//在集合中使用泛型：以HashMap为例
@Test
public void test02(){
Map<String ,Integer> map=new HashMap<>();
map.put("Tom",21);
map.put("Jerry",22);
map.put("Jack",54);
// map.put(12,"Rose");
//泛型的嵌套
Set<Map.Entry<String ,Integer>> entry= map.entrySet();
Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
while (iterator.hasNext()){
Map.Entry<String,Integer> e=iterator.next();
String key=e.getKey();
Integer value=e.getValue();
System.out.println(key+"---->"+value);
}
}
}
5.2 自定义泛型结构：泛型类、泛型接口
- 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如: <E1,E2,E3>
- 泛型类的构造器如下：public GenericClass(){}。 而下面是错误的：public GenericClass(){}
- 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
- 泛型不同的引用不能相互赋值。 >尽管在编译时ArrayList和ArrayList是两种类型，但是，在运行时只有 一个ArrayList被加载到JVM中。
- 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价 于Object。经验：泛型要使用一路都用。要不用，一路都不要用。
- 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
- jdk1.7，泛型的简化操作：ArrayList flist = new ArrayList<>();
- 泛型的指定中不能使用基本数据类型，可以使用包装类替换。
- 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。
- 异常类不能是泛型的
- 不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity]; 参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。
- 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：
- 子类不保留父类的泛型：按需实现
- 没有类型 擦除
- 具体类型
- 子类保留父类的泛型：泛型子类
- 全部保留
- 部分保留
- 子类不保留父类的泛型：按需实现
结论：子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型
package study.javaSenior.generic;
import org.junit.Test;
/**
* 如何自定义泛型结构：泛型类、泛型接口；泛型方法
*
* 1.关于自定义泛型类、泛型接口；
*
* @author zhengxu
* @create 2021-06-30 17:51
*/
public class GenericTest1 {
@Test
public void test(){
//如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
//要求：如果大家定义了类是带泛型的，建议在实例化时要指明类的泛型。
Order order=new Order();
order.setOrderId(123);
order.setOrderT("ABC");
//建议实例化时指明类的泛型
Order<String> order1=new Order<>("OrderAA",1001,"Abc");
order1.setOrderT("AA:hello");
}
@Test
public void test01(){
SubOrder sub1=new SubOrder();
//由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不需要再指明泛型。
sub1.setOrderT(1122);
//子类继承父类时，未指明泛型类型。则实例化子类对象时，需要指明泛型。
SubOrder1<String> sub2=new SubOrder1<>();
sub2.setOrderT("Order2.....");
}
}
package study.javaSenior.generic;
/**
* 自定义泛型类
* @author zhengxu
* @create 2021-06-30 17:18
*/
public class Order <T>{
String orderName;
int orderId;
//类的内部结构就可以使用类的泛型
T orderT;
public Order(){};
public Order(String orderName,int orderId,T orderT){
this.orderName=orderName;
this.orderId=orderId;
this.orderT=orderT;
}
public String getOrderName() {
return orderName;
}
public void setOrderName(String orderName) {
this.orderName = orderName;
}
public int getOrderId() {
return orderId;
}
public void setOrderId(int orderId) {
this.orderId = orderId;
}
//如下的三个方法都不是泛型方法
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 +
'}';
}
}
package study.javaSenior.generic;
/**
* @author zhengxu
* @create 2021-06-30 18:47
*/
public class SubOrder extends Order<Integer>{
}
package study.javaSenior.generic;
/**
* @author zhengxu
* @create 2021-06-30 18:54
*/
public class SubOrder1<T> extends Order<T>{//仍然是泛型类
}
【注意事项】：
class GenericTest {
public static void main(String[] args) {
// 1、使用时：类似于Object，不等同于Object
ArrayList list = new ArrayList();
// list.add(new Date());//有风险
list.add("hello");
test(list);// 泛型擦除，编译不会类型检查
// ArrayList<Object> list2 = new ArrayList<Object>();
// test(list2);//一旦指定Object，编译会类型检查，必须按照Object处理
}
public static void test(ArrayList<String> list) {
String str = "";
for (String s : list) {
str += s + ",";
}
System.out.println("元素:" + str);
}
}
class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son1 extends Father {// 等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2 extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2> extends Father<Integer, T2> {
}
class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son<A, B> extends Father{//等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2<A, B> extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2, A, B> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2, A, B> extends Father<Integer, T2> {
}
5.3 自定义泛型结构：泛型方法
-
方法，也可以被泛型化，不管此时定义在其中的类是不是泛型类。在泛型 方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。
-
泛型方法的格式：
[访问权限] <泛型> 返回类型 方法名([泛型标识 参数名称]) 抛出的异常
-
泛型方法声明泛型时也可以指定上限(在12.5中讲)
-
泛型方法：在方法中粗现了泛型的结构，泛型参数与类的泛型参数没有任何关系！！！
-
换句话说，泛型方法所属的类不是泛型类都没有关系
public<E> List<E> copyFromArrayToList(E[] arr){
ArrayList<E> list=new ArrayList<>();
for(E e:arr){
list.add(e);
}
return list;
}
public static <T> void fromArrayToCollection(T[] a, Collection<T> c) {
for (T o : a) {
c.add(o);
}
}
public static void main(String[] args) {
Object[] ao = new Object[100];
Collection<Object> co = new ArrayList<Object>();
fromArrayToCollection(ao, co);
String[] sa = new String[20];
Collection<String> cs = new ArrayList<>();
fromArrayToCollection(sa, cs);
Collection<Double> cd = new ArrayList<>();
// 下面代码中T是Double类，但sa是String类型，编译错误。
// fromArrayToCollection(sa, cd);
// 下面代码中T是Object类型，sa是String类型，可以赋值成功。
fromArrayToCollection(sa, co);
}
- **使用情景：**利用继承和泛型操作表的共性操作 P571
5.4 泛型在继承上的体现
5.5 通配符的使用
-
使用类型通配符：？
比如：List<?> ，Map<?,?>
Lis<?>t是List、List等各种泛型List的父类。
-
读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型 是什么，它包含的都是Object。
-
写入list中的元素时，不行。因为我们不知道c的元素类型，我们不能向其中 添加对象。
- 唯一的例外是null，它是所有类型的成员
package study.javaSenior.generic;
import org.junit.Test;
import study.javaSenior.commonlyClass.string.Person;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* @author zhengxu
* @create 2021-07-01 15:50
*/
public class GenericTest2 {
/*
1.泛型在继承方面的体现
类A是类B的父类，G<A>和G<B>不具备子父类关系，二者都是并列关系。
补充：类A是类B的父类，A<G>和B<G>是子父类关系。
*/
@Test
public void test(){
Object obj=null;
String str=null;
//子类可以赋值给父类
obj=str;
//编译不通过
// Date date=new Date();
// str=date;
List<Object> list1=null;
List<String> list2=null;
//此时的list1和list2不具备子父类关系的，报错
// list1=list2;
}
/*
2.通配符的使用
通配符：?
类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>
*/
@Test
public void test01(){
List<Object> list1=null;
List<String> list2=null;
List<?> list=null;
list=list1;
list=list2;
print(list1);
print(list2);
//使用通配符后数据的写入和读出要求！！！！！！！！！
List<String> list3=new ArrayList<>();
list3.add("AA");
list3.add("BB");
list3.add("CC");
list=list3;
//添加:对于list<?>就不能向其内内部添加数据。除了null之外
// list.add("DD");
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.有限制条件的通配符的使用
? extends Person：
G<? extends A> 可以作为G<A>和G<B>的父类的，其中B是A的子类。?<=A
? super Person：
G<? super A> 可以作为G<A>和G<B>的父类的，其中B是A的子类>=。?>=A
*/
@Test
public void test02(){
List<? extends Person> list1=null;//可以是Person或者Persob的子类
List<? super Person> list2=null;//可以是Person或者Person的父类
List<Stuent> list3=new ArrayList<>();
List<Person> list4=new ArrayList<>();
List<Object> list5=new ArrayList<>();
list1=list3;
list1=list4;
// list1=list5;//错误
list2=list4;
list2=list5;
// list2=list3;
//读取数据：
list1=list3;
Person p = list1.get(0);//至少是Person
// Stuent stu= list1.get(0);
list2=list4;
Object obj = list2.get(0);//只能是Object
//写入数据:
//编译不通过：万一是一个比Student还小的子类，就无法添加
// list1.add(new Stuent());
list2.add(new Person());//成功，只能放最低的类：Person
}
}
289
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
