Java学习笔记——泛型（一文了解Java中的泛型）

r囧r小猫 2022-11-02 11:44 205阅读 0赞

### 文章目录 ###

*  泛型
 *   *  什么是泛型
     *  为什么使用泛型
     *  怎么使用泛型
     *   *  使用已定义的泛型
         *  自定义泛型
         *   *  泛型类（接口）
             *  泛型方法
         *  通配符的使用
         *   *  普通通配符
             *  有限制条件的通配符

# 泛型 #

## 什么是泛型 ##

泛型**提出的背景**：集合类容器在**设计阶段/声明阶段**不能确定该容器实际存放什么类型的对象。但对**该对象的操作管理是确定**的，因此此时把元素类型设计成一个参数，这个**类型参数叫做泛型**。由此可知，泛型最早是为集合设立。

**泛型概念：允许在定义类、接口**时通过一个**标识**表示**类中某个属性的类型**或者是**某个方法的返回值**及**参数类型**。这个参数将在使用时（例如，**继承或实现接口**，用这个**类声明变量、创建对象**）确定（即**传入实际的类型参数**，也成为实型参数）。

由此可见，泛型的使用也就分为三类：**对接口、对类、对函数**。

## 为什么使用泛型 ##

如果不使用泛型，当使用集合时可能会出现类型不安全的问题，使得在进行类型转换的时候出现`ClassCastException`的异常，实例见如下代码（以`ArrayList`为例，其他容器类型同理）：

ArrayList list = new ArrayList();	//不使用泛型
    list.add(79);
    list.add(79);
    list.add(729);
    
    list.add("hello");	// 出现类型不安全问题

但如果在声明的时候增加了泛型就能避免上述问题（**注意泛型的类型不能是基本数据类型**）

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

一旦在声明的时候使用了泛型，在**集合类或接口**中**凡是定义类或接口时**，内部结构使（**比如：方法、构造器、属性**）用到泛型的位置都会**限定泛型类型**为`Integer`，由此**规范性和安全性也就得到了保障**。

## 怎么使用泛型 ##

### 使用已定义的泛型 ###

如`ArrayList`集合，`Map`集合，直接在实例化集合对象时传递参数即可。

--------------------

### 自定义泛型 ###

#### 泛型类（接口） ####

定义泛型类时，相当于**给该类添加了一个参数**，要求外界创建该类对象时**给定该参数一个类型**，以供该类在实例化时能**准确定义成员变量与成员方法**

1.  定义一个普通的带泛型的类

public class Order<T> { 
 String name;
 int orderId;
 
 // 类的内部就可以使用类的泛型
 T orderT;
 
 public Order() { 		// 空参构造器不需要加<>，但实例化的时候需要
 }
 
 public Order(String name, int orderId, T orderT) { 
 this.name = name;
 this.orderId = orderId;
 this.orderT = orderT;
 }
 
 public T getName(T orderT){ 
 return orderT;
 }
 
 public static void main(String[] args) { 
 Order order = new Order(); // 如果没指明类的泛型，则认为泛型就是Object
 
 Order<Integer> integerOrder = new Order<>();
 }
 }

换句话说，这里的泛型就相当于一个**全局约束规范**，凡是该类中涉及泛型的内容，都需要**遵守该规范（使用泛型类型）**

--------------------

1.  带继承的泛型类

此时情况相对复杂一些，当子类后面没有<>时，例如`Son1`和`Son2`，其就一定不是泛型类，只有子类后面也有<>时才为泛型类入`Son3`和`Son4`。

class Father<T1,T2>{ 
 }
 //子类不保留父类的泛型
 // 1）没有类型——擦出类型（转换为Object）
 class Son1 extends Father{ 	//等价于class Son extends Father<Object,Object>{}
 }
 // 2）有具体类型
 class Son2 extends Father{ 	//等价于class Son extends Father<Object,Object>{}
 }
 
 //子类保留父类泛型
 // 1）全部保留
 class Son3<T1,T2> extends Father<T1,T2>{ 
 }
 // 2）部分保留
 class Son4<T2> extends Father<Integer,T2>{ 
 }

⭐️**特别提示**：类中带泛型的方法**不能够是静态方法**，这是因为在调用该方法时并没有实例化对象，不知道泛型类型。

--------------------

#### 泛型方法 ####

泛型方法：**在方法中出现了泛型结构，泛型参数与类的泛型参数没有任何关系。**

首先需要明确一点，**泛型方法**和**带泛型的方法**不是一个概念。后者的泛型对象由**类定义时确定**，而前者的泛型是自己的的泛型。也就是说，即使在实例化对象时给定了泛型类型，**带泛型的方法可以得到该泛型类型，而泛型方法仍然不能，除非给其再次指定泛型类型**。

以上述Order类为例，`public T getName()`是带泛型的方法，但不是泛型方法，但如果再在`Order`类中添加如下方法

public class Order{ 
 // ...
 
 public <E> List<E> copyFromArrayToList(E[] arr){ 
 // 如果再List<E> 前不加<E>，编译器会认为存在一个 E 类，加了后编译器就知道该方法是泛型方法了
 ArrayList<E> list = new ArrayList<>();
 for(E e:arr){ 
 list.add(e)
 }
 return list;
 }
 
 // ...
 public static void main(String[] args) { 
 Order<Integer> integerOrder = new Order<>();
 		Integer[] arr = new Integer[]{ 1,2,3,4};
 List<Integer> list = order.copyFromArrayToList(arr)	
 //这时上面的泛型方法就会根据传入的数组类型，将其泛型设置为Integer
 }
 }

⭐️ **特别提示**：泛型方法可以使用静态方法，因为泛型方法没有使用类的泛型，不需要类实例化提供泛型参数。

⚠️写在最后（**一些注意事项**）

1. 每一个泛型类对象都是一个单独个体，多个不同泛型参数类型的对象**互为并列结构**。即使同一个泛型类互为父子的类型，两者也不不能完成父子关系。换句话说，虽然 **类A 是 类B 的父类**，但是G<A>和G 而这不具备子父类关系，二者是并列关系。见如下代码
 
 List<Object> list1 = null;
 List<String> list2 = new ArrayList<String>();
 
 list1 = list2; //错误
 
 反之，**A<G>是B<G>的父类**
 
 List<String> list1 = null;
 ArrayList<String> list2 = null;
 list1 = list2; //正确

### 通配符的使用 ###

#### 普通通配符 ####

首先考虑这样一个需求：我们希望构造一个方法，能够对所有的`List`集合实现赋值，不管`List`集合中存放的是什么内容。这是就可以考虑使用通配符`?`，请看如下代码：

public class Order{ 
 
 //. Order类的其他代码
 
 public static void main(String[] args) throws Exception { 				
 List list1 = new ArrayList();
 list1.add(1221);
 list1.add("tome");
 Order.print(list1);//这个时候就可以输出输出 1221和tome
 
 List<Integer> list2 = new ArrayList();
 list2.add(12);
 List<String> list3 = new ArrayList();
 list3.add("tom");
 
 Order.print(list2);// 12
 Order.print(list3);//tom
 }
 
 public static void print(List<?> list){ 
 Iterator<?> iterator = list.iterator();
 while(iterator.hasNext()){ 
 System.out.println(iterator.next());		
 }
 }
 }

可以发现，使用通配符就相当于给G<A>和G类构造了一个**公共父类G<?>**，定义类G<?>可以使用的位置G<A>和G都可以使用。同时之前会出现**类型转换异常的方法在这里也得以消除**。当然这也就有违背泛型使用的初衷，会造成类型不安全问题。

#### 有限制条件的通配符 ####

这里主要考虑的是如下两种通配符的使用

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

上述内容换句话说就是如下两种情况：

*  当容器的泛型是`? extends 类A`，该类可以通配使用所有A的子类（包括A自身），**通配范围(-∞，A\]**。
 *  当泛型是`? super 类A`，该类可以通配使用所有A的父类（包括A自身），**通配范围\[A，+∞)**。
    
    说明：可以预见，泛型是`?`时，**通配范围是(-∞，+∞)**

请看如下代码：

public void test(){ 
 List<? extends Person> list1 = null;
 List<? super Person> list1 = null;
 
 List<Student> list3 = null;
 List<Student> list4 = null;
 List<Student> list5 = null;
 
 list1 = list3;	//编译通过
 list1 = list4;	//编译通过
 list1 = list5;	//编译不通过
 
 list2 = list3;	//编译不通过
 list2 = list4;	//编译通过
 list2 = list5;	//编译通过
 }