泛型的本质：泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数
化。
总的来说，泛型就是把类型参数化了，即给类型一个指定的参数，在使用时指定参数具体的值，这个类型就可以在使用的时候决定了，这样就可以编写应用于多种类型的代码。
泛型代码注释：List<>给String类型，代表List这个集合操作的是String类型的数据，且，=后面的ArrayList<>，这里的<>里的值可以省略。 |
|---|
泛型的目的：是指定当前容器，要持有什么类型的对象，让编译器去做检查，检查类型的安全性，并且所有的强制转换都是隐式转换的。此时，就需要把类型，作为参数传递，提高了代码的复用性。
| 作用 |
|---|
| 1.安全性 2.消除转换 3. 提高性能 4. 复用性 |
class 泛型类的名称<类型形参列表>{
//代码块内使用类型参数
}
class Student<T1,T2....Tn>{
}
class 泛型类型名称<类型形参列表> extends 继承类<类型形参列表>
//示例
class Mike<Integer> extends Student<Integer>{
}
//可以只是用部分类型参数
class Rose<T1,T2..Tn> extends Student<T1>{
}
| 泛型类 | public class Student <T1,T2...>{...;} |
|---|---|
| 泛型方法 | public T func(T[] arr,T root){....;} |
| 泛型接口 | public calss Student<T1> implements Comparable<T1>{...;} |
T代表占位符，表示这个类或者是变量、方法是一个泛型，需要传类型参数，就好比一个函数有一个参数，你调用它需要给它传参，否则就会报错，这个T其实就是形参名，可以改成E、K...V、T都可以 |
|---|
了解：【命名规范】类型形参一般使用一个大写字母表示，常用的名称有：
| E | 表示Element(元素) |
|---|---|
| K | 表示Key(钥匙、键) |
| V | 表示Value(值) |
| N | 表示Number(数) |
| T | 表示Type(类型) |
| S,U,V等 | 第二，第三，第四个类型 |
T类型T[] arr = new T[10]//error |
< Integer >是指定当前类型,new Student<>，这里的<>内可加也可不加Integer。Integer，此时在注释4处，存放元素时，编译器就会帮助我们进行类型检查。在JAVA中，由于基本类型不是继承于Object，为了在泛型代码中可以支持基本类型，JAVA给每个基本类型都对应了一个包装类。
| 基本数据类型 | 包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
int a = 10;
/*
装箱操作
*/
Integer b = Integer.value(a); //调用value方法
Integer c new Integer(a);//调用构造方法
/*
拆箱操作
*/
int d = c.intValue();
在下面几行行代码，编译器自动调用了
Integer.valueof()，属于自动装包和拆包。
public static void main(String[] args) {
Integer a = 100;
Integer b = 100;
Integer c = 200;
Integer d = 200;
System.out.println(a == b);
System.out.println(c == d);
}
在编译的过程中，将所有的T都替换为Object的这种机制，称为：擦除机制。JAVA的泛型机制是在编译时实现的，编译器生成的字节码在运行期间并不包含泛型的类型信息(运行时没有泛型这么一说了)。
| 泛型擦除机制的文章介绍： |
|---|
| 链接 |
T[] T = new T[10];是不对的。编译的时候替换为Object，不是相当于：Object[] T = new Object[10];
| 解答 1. |
|---|
| 泛型数组不能实例化 |
T[]擦除成了Object，Object是不能用其他类型接收的，因为Object可以存各种类型，把Object里的元素取出来转换成某个具体元素，是不安全的，JAVA不支持这么做。
数组和泛型之间有一个重要的区别就是：它们是如何强制执行类型检查。 数组在运行时存储和检查类型信息，而泛型是在编译时检查类型错误。
所以：泛型是不能实例化泛型类型数组。前面我写的T[] t = (T[]) new Obeject[10];其实也是错的。
| 解答2. |
|---|
| 一定是都擦除成了Object，前面我已经说过了。 |
class 泛型类名称 <类型形参> extends<类型形参> {
//....
}
示例：
class Myarray{
//..
}
class Int extends Myarray{
//..
}
class Long extends Int{
//...
}
public class Maths<E extends Myarray>{
//...
}
解释：Maths<E extends Myarray>的E只能是Myarray的子类，也就是说**E接受的类型实参只能是Myarray的子类**。
再看一个例子：
class Student<E extends Number>{
E[] arr;
E Name;
}
public class Test {
public static void main(String[] args) {
Student<Integer> in;//1
Student<String> str;//2
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6YVc6XOJ-1665319877790)(C:\Users\COFFEEWEN\AppData\Roaming\Typora\typora-user-images\image-20221009194623454.png)]
**解释：**注释1处，编译正确，因为Integer是Number的子类型，注释2处，编译错误，因为String不是Number的子类型。
了解：Number是 java.lang包下的一个抽象类，提供了将包装类型拆箱成基本类型的方法，所有基本类型的包装类型都继承了该抽象类，并且是final声明不可继承改变；
了解：没有指定类型边界 E，可以视为 E extends Object。
| 通配符： |
|---|
?用于在泛型的使用，即为通配符 |
<?>无边界通配符 |
<? extends E>上界的通配符，E为上界 |
<? super E>下界的通配符，E为下界 |
通配符是用于解决泛型之间引用传递问题的特殊语法，更为灵活，多用于扩大参数的范围。
class Fruits<T>{
private T fruits;
public T getFruits(){
return this.fruits;
}
public void setFruits(T fruits){
this.fruits = fruits;
}
}
public class Demo {
public static void main(String[] args) {
Fruits<String> fruits1 = new Fruits<>();
fruits1.setFruits("苹果");
put(fruits1);//输出
Fruits<Integer> fruits2 = new Fruits<>();
fruits2.setFruits(100);
put(fruits2);
}
public static void put(Fruits<?> tmp){//1.
System.out.println("这个水果是："+tmp.getFruits());
tmp.setFruits("banana");//2.无法修改
tmp.setFruits(66);//3.无法修改
Fruits ret = tmp.getName();//4.无法接收
}
}
解释：
注释1：处 put(Fruits<?> tmp)使用无边界通配符，说明它是可以接受任意类型，所以当不同类型的fruits1和fruits2调用put进行传参时，并不会报错。
注释2处、3处：由于是可以接受任意类型的，tmp是不确定类型的，不允许进行修改操作。比如，你此时传入了一个String类型的(传参时不会报错)，可是你代码里写的是tmp.setFruits(66)设置的是int型，这样是很不安全的，所以编译器直接不允许你这么写。
注释4处：传入的参数类型是不确定的，不能用Fruits来接收。
class Apple extends Fruits{
}
class Banana extends Fruits{
}
class Fruits extends Meat{
}
class Meat{
}
class Food<T>{
private T name;
public T getName(){
return this.name;
}
public void setName(T name){
this.name = name;
}
}
public class Demo {
public static void main(String[] args) {
Food<Apple> appleFood = new Food<>();
//因为Food<T> 给的类型是Apple，所以你只能给相同类型的数据
appleFood.setName(new Apple());
fun(appleFood);
Food<Banana> bananaFood = new Food<>();
bananaFood.setName(new Banana());
fun(bananaFood);
}
public static void fun(Food<? extends Fruits> tmp){//1.
System.out.println(tmp.getName());
tmp.setName(new Banana());//2.无法修改
tmp.setName(new Apple());//3.无法修改
Fruits ret = tmp.getName();//读取数据
}
解释：
public static void main(String[] args) {
Food<Fruits> f1 = new Food<>();
f1.setName(new Fruits());
fun(f1);
Food<Meat> f2 = new Food<>();
f2.setName(new Meat());
fun(f2);
}
public static void fun(Food<? super Fruits> tmp){//1.
System.out.println(tmp.getName());//只能直接输出
tmp.setName(new Banana());//2.可以修改
tmp.setName(new Fruits());//3.可以修改
Fruits ret = tmp.getName();//4.不能读取数据
}
解释：
| 总结 | |
|---|---|
| <?>无边界通配符 | 可以传入任意实参类型，不能写入，不能读取，只能输出。 |
| <? extends 上界> | 可以传入实参类型是上界或者上界的子类，不能写入，可以读取。 |
| <? super 下界> | 可以传入实参类型是下界或者下界的父类，不能读取，可以写入数据。 |
配符下界：不能读取数据，可以写入数据。
public static void main(String[] args) {
Integer a = 100;
Integer b = 100;
Integer c = 200;
Integer d = 200;
System.out.println(a == b); //1.
System.out.println(c == d); //2.
}
解释：
Integer源码有一个cache数组事先存储了【-128,127】之间的数据，总共256个数据，这些数据被static final修饰，是不能改变的。当赋的值是在这个区间里，会直接在这个数组里读取，也就是变量a和b，指向了同一个对象，所以输出true。当超过了这个区间，每次都会重新new一个对象，所以输出false。