一文搞懂泛型——泛型简介/优点/上界/通配符

朱雀 2024-04-01 15:05 110阅读 0赞

**目录**

1.泛型简介

2.泛型的优点

3.泛型的上界

2.1 特殊的泛型上界

4.泛型的通配符

4.1 简介

4.2 通配符的上界

4.3 通配符的下界

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

## **1.泛型简介** ##

**一般的类或者方法，只能运用具体的类型：即基本类型、自定义的类。若要编写可以用于多种类型的代码，这种刻板的限制对编写代码的束缚会很大。 ——《Java编程思想》**

泛型是JDK5.1引入的语法，通俗的讲，泛**型就是适用于许多的类型，代码上讲是对类型实现了参数化。**

**泛型是Java中比较难的语法**

例如：

class MyArray{
        public Object[] objects = new Object[10];
    
        public void set(int pos,Object val){
            objects[pos] = val;
        }
    
        public Object get(int pos){
            return objects[pos];
        }
     }
    
    public class Main {
         public static void main(String[] args) {
             MyArray myArray = new MyArray();
             myArray.set(0,"hello");
             String str = myArray.get(0);
             String str1 = <String>myArray.get(0);
    
             System.out.println(str1);
         }
    }

对于以上代码，虽然指定了MyArray类中的objects数组类型为Object，并且在main函数中，让objects数组的0下标为字符串“hello”，但在“String str = myArray.get(0);”这行代码中会报错,只能进行强制类型转换，才可输出“hello”。

对于以上问题，就可以利用泛型。**将类名改为“MyArray<T>”，此时，MyArray就是一个泛型类“T”可当作是一个占位符。**同时更改类中的类型名称。

上述代数可更改为：

class MyArray<T>{
        public T[] objects = (T[])new Object[10];
    
        public void set(int pos,T val){
            objects[pos] = val;
        }
    
        public T get(int pos){
            return objects[pos];
        }
    }
    public class Main{
        public static void main(String[] args) {
            MyArray<String> myArray = new MyArray<String>();
            myArray.set(0,"hello");
            myArray.set(1,10);
            String str = myArray.get(0);
            System.out.println(str);
        }
    }

在My Array类中，将Object类型改为T类型，在main函数中，MyArray后加上想要的类型，此时加的是<String>，这样“String str = myArray.get(0);”就不报错了，不用再进行强制类型转换。但是“myArray.set(1,10);”这行代码会报错。即就是编译的时候，会自动进行类型检查。

再看如下代码

public class Main{
        public static void main(String[] args) {
            MyArray<String> myArray = new MyArray<String>();
            myArray.set(0,"hello");
            myArray.set(1,10);
            String str = myArray.get(0);
            System.out.println(str);
    
            MyArray<Integer> myArray2 = new MyArray<Integer>();
            MyArray<int> myArray3 = new MyArray<int>();
        }
    }

“MyArray<Integer> myArray2 = new MyArray<Integer>();”不报错  
“MyArray<int> myArray3 = new MyArray<int>();”报错

**这表明对于基本类型来说，不能作为泛型类型的参数。**

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>原类型</td> 
   <td>包装类</td> 
  </tr> 
  <tr> 
   <td>byte</td> 
   <td>Byte</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>Short</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>Integer</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>Long</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>Float</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>Double</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>Character</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>Boolean</td> 
  </tr> 
 </tbody> 
</table>

## 2.泛型的优点 ##

**1.数据类型参数化**

**2.编译时会自动进行类型的检查与转换**

接下类从底层看一下泛型

在Java当前的文档中打开至这个界面，可根据![f618dc34d37542dea25cdaf8ed850cf3.png][]

此处在空白处鼠标单击右键，选择用powershell打开，并输入指令“javap -c MyArray”，回车

![97bfcea5c71945a8b045587d90d834cf.png][]

发现有好多的Objec。这表名编译当中，所有的T替换为Obejct，这种替换方式称为：**擦除机制**

详细的泛型及泛型的擦除机制介绍：[https://zhuanlan.zhihu.com/p/51452375][https_zhuanlan.zhihu.com_p_51452375]

## 3.泛型的上界 ##

例如

> public class MyArray<E extends Number>\{
> 
> ......
> 
> \}

此时 “MyArray<Integer> myArray = new MyArray<Integer>();”

“MyArray<Number> myArray = new MyArray<Number>();”都是可以的，但是

“MyArray<String> myArray = new MyArray<String>();”会报错。因为E只能是Nubmer或者Number的子类。这就是泛型的上界。泛型没有下界

> public class MyArray<T>\{
> 
> ......
> 
> \}

没有指定上界，则默认是Object，视为<T extends Object>

### 2.1 特殊的泛型上界 ###

这是一个寻找数组最大值的方法，类中是T类型的参数

class Find<T>{
         public T findMax(T[] array){
             T max = array[0];
             for (int i = 1; i < array.length; i++) {
                 if(max < array[i]){
                     max = array[i];
                 }
             }
             return max;
         }
    }

此时发现“ if(max < array\[i\])”这行代码报错了。**原因是T类型是引用类型**，无法通过“< ，> ，!=”等比较，需要利用compare进行比较。

则以上代码更改为

class Find<T extends Comparable<T>>{
         public T findMax(T[] array){
             T max = array[0];
             for (int i = 1; i < array.length; i++) {
                 if(max.compareTo(array[i]) < 0 ){
                     max = array[i];
                 }
             }
             return max;
         }
    }

测试用例：

public class Main {
        public static void main(String[] args) {
            Integer[] array = {2,34,45,12,76,80,22,35,10};
            Find<Integer> find = new Find<Integer>();
            int max = find.findMax(array);
            System.out.println("array数组最大值为: " + max);
    
            String[] strings = {"hello","i love u","qwerty"};
            Find<String> find2 = new Find<String>();
            String str = find2.findMax(strings);
            System.out.println("str数组最大值为: " + str);
    
        }
        
    }

测试结果：

![21129e4b533449ccbd63f9e392d37f55.png][]

**注意：这里的extends不是继承**

## **4.泛型的通配符** ##

### 4.1 简介 ###

通配符是为了解决泛型无法协变的问题，协变是指如果Student是Person的子类，那么List<Student>也应该是List<Person>的子类。但是泛型是不支持这样的父子类关系。

> 1.泛型T是一个确定的类型，**一旦传入类型就确定下来**，而通配符更加灵活且不确定，更多的是用于扩充参数的范围。
> 
> 2.可以理解为**T就是一个变量**，传入具体的类型就确定下来，而通配符可以规定能传那些参数。

例如

class Alg{
        public static <T> void print1(ArrayList<T> list){
            for (T x:list) {
                System.out.println(x);
            }
        }
    
        public static void print2(ArrayList<?> list){
            for (Object x:list) {
                System.out.println(list);
            }
        }
    }

### 4.2 通配符的上界 ###

**语法：<? extends 上界>**

举例：

// 可以传入类型实参是 Number 子类的任意类型的 MyArrayList
    public static void printAll(MyArrayList<? extends Number> list) {
    ...
    }
    // 以下调用都是正确的
    printAll(new MyArrayList<Integer>());
    printAll(new MyArrayList<Double>());
    printAll(new MyArrayList<Number>());
    // 以下调用是编译错误的
    printAll(new MyArrayList<String>());
    printAll(new MyArrayList<Object>());

### 4.3 通配符的下界 ###

**语法：<? extends 上界>**

举例：

// 可以传入类型实参是 Integer 父类的任意类型的 MyArrayList
    public static void printAll(MyArrayList<? super Integer> list) {
    ...
    }
    // 以下调用都是正确的
    printAll(new MyArrayList<Integer>());
    printAll(new MyArrayList<Number>());
    printAll(new MyArrayList<Object>());
    // 以下调用是编译错误的
    printAll(new MyArrayList<String>());
    printAll(new MyArrayList<Double>());

[f618dc34d37542dea25cdaf8ed850cf3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/11ff25be11764def92b43730e86a3b6a.png
[97bfcea5c71945a8b045587d90d834cf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/200327de8a8a407888d5233022351f88.png
[https_zhuanlan.zhihu.com_p_51452375]: https://zhuanlan.zhihu.com/p/51452375
[21129e4b533449ccbd63f9e392d37f55.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/41f1f8a81c5540ada593873d9d3fcf15.png