前言
泛型是一种编程概念，它允许我们编写可以适用于多种数据类型的代码。通过使用泛型，我们可以在编译时期将具体的数据类型作为参数传递给代码，从而实现代码的复用和灵活性。
在传统的编程中，我们通常需要为不同的数据类型编写不同的代码，这样会导致代码冗余和维护困难。而泛型的出现解决了这个问题，它使得我们可以编写一次代码，然后在需要的地方使用不同的数据类型进行实例化~
欢迎关注个人主页：逸狼
创造不易，可以点点赞吗~
如有错误，欢迎指出~
目录
前言
包装类
装箱
法一（过时方法）
法二（手动装箱）
法三（自动装箱）
拆箱
泛型
现在有一个需求
不使用泛型
使用泛型
泛型的上界
应用
泛型方法
泛型方法举例
泛型方法静态化
包装类
在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 表示 Element
- K 表示 Key
- V 表示 Value
- N 表示 Number
- T 表示 Type
- S, 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);
}
