前言
泛型是一种编程概念，它允许我们编写可以适用于多种数据类型的代码。通过使用泛型，我们可以在编译时期将具体的数据类型作为参数传递给代码，从而实现代码的复用和灵活性。
在传统的编程中，我们通常需要为不同的数据类型编写不同的代码，这样会导致代码冗余和维护困难。而泛型的出现解决了这个问题，它使得我们可以编写一次代码，然后在需要的地方使用不同的数据类型进行实例化~
欢迎关注个人主页：逸狼
创造不易，可以点点赞吗~
如有错误，欢迎指出~
目录
前言
包装类
装箱
法一（过时方法）
法二（手动装箱）
法三（自动装箱）
拆箱
泛型
现在有一个需求
不使用泛型
使用泛型
泛型的上界
应用
泛型方法
泛型方法举例
泛型方法静态化
包装类
在Java中，由于基本类型不是继承自Object，为了在泛型代码中可以支持基本类型，Java给每个基本类型都对应了 一个包装类型。
除了 Integer 和 Character， 其余基本类型的包装类都是首字母大写。
装箱
法一（过时方法）
法二（手动装箱）
public static void main(String[] args) { int a=10;// Integer ii=new Integer(a);//该方法已过时 Integer ii=Integer.valueOf(a);//将基本类型int变为引用类型Integer }法三（自动装箱）
Integer ii=a;拆箱
public static void main(String[] args) { Integer ii=10;//自动装箱 int a=ii;//自动拆箱 int aa=ii.intValue();//手动拆箱 }泛型
一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的 代码，这种刻板的限制对代码的束缚就会很大。----- 来源《Java编程思想》对泛型的介绍。
泛型是在JDK1.5引入的新的语法。用于把类型参数化。将类型以参数的形式进行传递。
所有类的父类默认都是Object类
现在有一个需求
实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值？
不使用泛型
class MyArray{ public Object[] array=new Object[10]; public void setArray(int pos,Object x){ array[pos]=x; } public Object getVal(int pos){ return array[pos]; }}public class Test { public static void main(String[] args) { MyArray myArray=new MyArray(); myArray.setArray(0,1); myArray.setArray(1,20); myArray.setArray(2,"hello"); String s=(String)myArray.getVal(2);//getVal的返回类型是Object类，而接收的类型是String类型，要强制转换为String类型，否则会报错 System.out.println(s); }}任何类型的数据在这里都可以存放，但是当数组的元素过多时，每一个元素都要强制类型转换就显得不方便了。
虽然在这种情况下，当前数组任何数据都可以存放，但是，更多情况下，我们还是希望他只能够持有一种数据类 型。而不是同时持有这么多类型。所以，泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译 器去做检查。此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。
使用泛型
class MyArray<T> {//在类的后面加上<> ,<T>代表占位符，表示当前类是一个泛型类 public Object[] array = new Object[10]; public void setArray(int pos, T x) { array[pos] = x; } public T getVal(int pos) { return (T) array[pos]; }}public class Test { public static void main(String[] args) { //<Integer>代表传的数据类型是整形类型， // 后面的MyArray<>可以不写Integer，编译器会通过前面的推导，但是要加上<> MyArray<Integer> myArray=new MyArray<>(); //只能写类 类型，不能写简单类型 //MyArray<int> myArray=new MyArray<>();//err myArray.setArray(0,1); myArray.setArray(1,2); //编译的时候，每次存储x值，会检查是否是指定的数据类型，若不一样，会报错// myArray.setArray(1,"hello");// 这里不需要进行强制类型转换，因为放数据的时候就进行了严格的检查 Integer x= myArray.getVal(1); MyArray<String> myArray2=new MyArray<>(); myArray2.setArray(0,"hewsa"); System.out.println(myArray2.getVal(0)); }【规范】类型形参一般使用一个大写字母表示，常用的名称有：
E 表示 ElementK 表示 KeyV 表示 ValueN 表示 NumberT 表示 TypeS, U, V 等等 - 第二、第三、第四个类型泛型的编译——擦除机制
擦除机制：在编译的过程当中，将所有的T替换为Object这种机制。 Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。
泛型的上界
在定义泛型类时，有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束。
语法
class 泛型类名称<类型形参 extends 类型边界> {
...
}
例如下面代码表示 只接受 Number 的子类型作为 E 的类型实参
public class MyArray<E extends Number> { ...}应用
定义一个泛型类，用于找到数组中最大值
//定义一个泛型类，找到数组中最大值class Alg<T extends Comparable<T>>{//表示传的泛型都是要实现Comparable接口的 public T findMax(T[]array){ T max=array[0]; for (int i = 0; i < array.length; i++) {// if(array[i]>max){//引用类型不能直接比较，会报错，要实现comparable接口比较 if(array[i].compareTo(max)>0){ max=array[i]; } } return max; }}public class Test { public static void main(String[] args) { Alg<Integer> alg=new Alg<>(); Integer [] array={1,2,3,4,5,6,7}; Integer x =alg.findMax(array); System.out.println(x); }结果：7
泛型方法
泛型方法举例
class Alg2{ //泛型方法 public<T extends Comparable <T>> T findMax(T[]array){ T max=array[0]; for (int i = 0; i < array.length; i++) { if(array[i].compareTo(max)>0){ max=array[i]; } } return max; }}public class Test { public static void main(String[] args) { Alg2 alg2 =new Alg2(); Integer[] array={1,2,3,4,5,6,7};// Integer x =alg2.<Integer>findMax(array); Integer x =alg2.findMax(array);//不写<Integer>也行，编译器会通过前面来推导 System.out.println(x); }泛型方法静态化
class Alg3{ //泛型方法静态化 相较于泛型方法，只是加了static而已 public static <T extends Comparable <T>> T findMax(T[]array){ T max=array[0]; for (int i = 0; i < array.length; i++) { if(array[i].compareTo(max)>0){ max=array[i]; } } return max; }}public class Test { public static void main(String[] args) { Integer[] array={1,2,3,4,5,6,7}; Integer x =Alg3.findMax(array);//静态方法直接通过类名调用 System.out.println(x); }
