JAVA基础 - 泛型机制解读 - 《JAVA基础》

作用
意义：
- 多元泛型类:
泛型接口
深入理解泛型

:::tips Java泛型这个特性是从JDK 1.5才开始加入的，因此为了兼容之前的版本，Java泛型的实现采取了“伪泛型”的策略，即Java在语法上支持泛型，但是在编译阶段会进行所谓的“类型擦除”（Type Erasure），将所有的泛型表示（尖括号中的内容）都替换为具体的类型（其对应的原生态类型），就像完全没有泛型一样。增加了灵活性. :::

作用

:::tips 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。 :::

意义：

适用于多种数据类型执行相同的代码（代码复用）

如下: ```java private static int add(int a, int b) { System.out.println(a + “+” + b + “=” + (a + b)); return a + b; }

private static float add(float a, float b) { System.out.println(a + “+” + b + “=” + (a + b)); return a + b; }

private static double add(double a, double b) { System.out.println(a + “+” + b + “=” + (a + b)); return a + b; }


- 如果没有泛型，要实现不同类型的加法，每种类型都需要重载一个add方法；通过泛型，我们可以复用为一个方法：
```java
private static <T extends Number> double add(T a, T b) {
    System.out.println(a + "+" + b + "=" + (a.doubleValue() + b.doubleValue()));
    return a.doubleValue() + b.doubleValue();
}

泛型中的类型在使用时指定，不需要强制类型转换（类型安全，编译器会检查类型）

在List中的使用 ```java //可以存放各种类型 List list = new ArrayList(); list.add(“xxString”); list.add(100d); list.add(new Person());

//只能存放String类型 List list = new ArrayList();

// list中只能放String, 不能放其它类型的元素

<a name="oJr7C"></a>
## 基本使用:
<a name="Vg0Ru"></a>
### 泛型类
<a name="S5ChP"></a>
#### 简单泛型类：
```java
class Point<T>{         // 此处可以随便写标识符号，T是type的简称  
    private T var ;     // var的类型由T指定，即：由外部指定  
    public T getVar(){  // 返回值的类型由外部决定  
        return var ;  
    }  
    public void setVar(T var){  // 设置的类型也由外部决定  
        this.var = var ;  
    }  
}  
public class GenericsDemo06{  
    public static void main(String args[]){  
        Point<String> p = new Point<String>() ;     // 里面的var类型为String类型  
        p.setVar("it") ;                            // 设置字符串  
        System.out.println(p.getVar().length()) ;   // 取得字符串的长度  
    }  
}

多元泛型类:

class Notepad<K,V>{       // 此处指定了两个泛型类型  
    private K key ;     // 此变量的类型由外部决定  
    private V value ;   // 此变量的类型由外部决定  
    public K getKey(){  
        return this.key ;  
    }  
    public V getValue(){  
        return this.value ;  
    }  
    public void setKey(K key){  
        this.key = key ;  
    }  
    public void setValue(V value){  
        this.value = value ;  
    }  
} 
public class GenericsDemo09{  
    public static void main(String args[]){  
        Notepad<String,Integer> t = null ;        // 定义两个泛型类型的对象  
        t = new Notepad<String,Integer>() ;       // 里面的key为String，value为Integer  
        t.setKey("汤姆") ;        // 设置第一个内容  
        t.setValue(20) ;            // 设置第二个内容  
        System.out.print("姓名；" + t.getKey()) ;      // 取得信息  
        System.out.print("，年龄；" + t.getValue()) ;       // 取得信息  

    }  
}

泛型接口

简单的泛型接口 ```java //接口 interface Info{ // 在接口上定义泛型
public T getVar() ; // 定义抽象方法，抽象方法的返回值就是泛型类型
}

//实现类 class InfoImpl implements Info{ // 定义泛型接口的子类
private T var ; // 定义属性
public InfoImpl(T var){ // 通过构造方法设置属性内容
this.setVar(var) ;
}
public void setVar(T var){
this.var = var ;
}
public T getVar(){
return this.var ;
}
}

//测试类 public class GenericsDemo24{
public static void main(String arsg[]){
Info i = null; // 声明接口对象
i = new InfoImpl(“汤姆”) ; // 通过子类实例化对象
System.out.println(“内容：” + i.getVar()) ;
}
}

<a name="SAgIs"></a>
### 泛型方法

- 泛型方法，是在调用方法的时候指明泛型的具体类型。重点看下泛型的方法
1. 定义泛型方法语法格式

![1655688003(1).png](https://cdn.nlark.com/yuque/0/2022/png/26235396/1655688014695-4e6cd529-b39f-436c-bc29-d9b6c848614b.png#clientId=uf1d6a708-b24c-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=537&id=ub21d7086&margin=%5Bobject%20Object%5D&name=1655688003%281%29.png&originHeight=537&originWidth=1116&originalType=binary&ratio=1&rotation=0&showTitle=false&size=73257&status=done&style=none&taskId=ua5ec4e57-c7a9-4beb-a103-8680b767729&title=&width=1116)

2. 调用泛型方法语法格式

![1655688086(1).png](https://cdn.nlark.com/yuque/0/2022/png/26235396/1655688097595-49fef900-ab68-4bc4-9f1b-3fe33d1b9e1a.png#clientId=uf1d6a708-b24c-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=224&id=ud88197a7&margin=%5Bobject%20Object%5D&name=1655688086%281%29.png&originHeight=224&originWidth=904&originalType=binary&ratio=1&rotation=0&showTitle=false&size=28552&status=done&style=none&taskId=u9e59a83c-32a1-416a-848d-d4af8b8250b&title=&width=904)
<a name="KXoMU"></a>
#### 说明:

1. 定义泛型方法时，必须在返回值前边加一个<T>，来声明这是一个泛型方法，持有一个泛型T，然后才可以用泛型T作为方法的返回值。
1. Class<T>的作用就是指明泛型的具体类型，而Class<T>类型的变量c，可以用来创建泛型类的对象。
1. 为什么要用变量c来创建对象呢？既然是泛型方法，就代表着我们不知道具体的类型是什么，也不知道构造方法如何，因此没有办法去new一个对象，但可以利用变量c的newInstance方法去创建对象，也就是利用反射创建对象。
1. 泛型方法要求的参数是Class<T>类型，而Class.forName()方法的返回值也是Class<T>，因此可以用Class.forName()作为参数。其中，forName()方法中的参数是何种类型，返回的Class<T>就是何种类型。在本例中，forName()方法中传入的是User类的完整路径，因此返回的是Class<User>类型的对象，因此调用泛型方法时，变量c的类型就是Class<User>，因此泛型方法中的泛型T就被指明为User，因此变量obj的类型为User。
1. 当然，泛型方法不是仅仅可以有一个参数Class<T>，可以根据需要添加其他参数。
1. **为什么要使用泛型方法呢**？因为泛型类要在实例化的时候就指明类型，如果想换一种类型，不得不重新new一次，可能不够灵活；而泛型方法可以在调用的时候指明类型，更加灵活。
<a name="Wss3S"></a>
### 泛型数组

1. 首先，我们泛型数组相关的申明：
```java
List<String>[] list11 = new ArrayList<String>[10]; //编译错误，非法创建 
List<String>[] list12 = new ArrayList<?>[10]; //编译错误，需要强转类型 
List<String>[] list13 = (List<String>[]) new ArrayList<?>[10]; //OK，但是会有警告 
List<?>[] list14 = new ArrayList<String>[10]; //编译错误，非法创建 
List<?>[] list15 = new ArrayList<?>[10]; //OK 
List<String>[] list6 = new ArrayList[10]; //OK，但是会有警告

那么通常我们如何用呢？

讨巧的使用场景

public class GenericsDemo30{  
  public static void main(String args[]){  
      Integer i[] = fun1(1,2,3,4,5,6) ;   // 返回泛型数组  
      fun2(i) ;  
  }  
  public static <T> T[] fun1(T...arg){  // 接收可变参数  
      return arg ;            // 返回泛型数组  
  }  
  public static <T> void fun2(T param[]){   // 输出  
      System.out.print("接收泛型数组：") ;  
      for(T t:param){  
          System.out.print(t + "、") ;  
      }  
  }  
}

合理使用 ```java public ArrayWithTypeToken(Class type, int size) { array = (T[]) Array.newInstance(type, size); }

```

深入理解泛型

……