java加强 -泛型

概念

定义类、接口、方法时，同时声明了一个或多个类型变量（如<E>），称为泛型类、泛型接口、泛型方法、它们统称为泛型。

语法

public class ArrayList<E>{}

E可以接收不同类型的数据，可以是字符串，也可以是学生类等东西。

作用：泛型提供了在编译阶段约束所能操作的数据类型，并自动进行检查的能力，这样可以避免强制类型转换，及其可能出现的异常。

接下来用常见API，ArrayList集合举例

package GenericityDemo;import java.util.ArrayList;public class GenericDemo1 {public static void main(String[] args) {
//        //认识泛型
//        ArrayList list = new ArrayList();           //没有使用泛型，存储任意类型数据
//        list.add("hello");
//        list.add(100);
//        list.add(true);
//        //获取数据
//        for (int i = 0; i < list.size(); i++)
//        {
//            Object obj = list.get(i);       //必须用Object接收，因为存储的任意类型数据
//            //数据转型处理
//            String s = (String) list.get(i);//运行到整型时程序会崩，因此最好要统一数据类型
//            System.out.println(s);
//        }ArrayList<String> list = new ArrayList<String>();       //泛型约束，只能存储String类型数据list.add("hello");list.add("world");//list.add(90);     //类型不是泛型约束的类型，报错for (int i = 0; i < list.size(); i++){String s = list.get(i);     //类型确定，不用转型System.out.println(s);      //不会出现异常}}
}

一、泛型类

泛型类（Generic Class） 是通过类型参数化定义的类，其核心作用是通过类型抽象实现代码的通用性、类型安全性和灵活性。

语法

修饰符 class 类名<类型变量，类型变量....>{}

public class ArrayList<E>{
......
}

示例

创建一个ArrayList集合类（其实就是在自己的类里用之前的API，但接收的数据类型由我们限制）

package GenericityDemo;import java.util.ArrayList;public class MyArrayList <E>{private ArrayList list = new ArrayList();public boolean add(E e){list.add(e);return true;}public boolean remove(E e){return  list.remove(e);}@Overridepublic String toString() {return list.toString();}
}

package GenericityDemo;public class GenericDemo2 {public static void main(String[] args) {//目标：学会自定义泛型类//需求：模拟ArrayList集合，自定义一个集合MyArrayListMyArrayList<String> list = new MyArrayList<>();//jdk7支持后面不写泛型类型list.add("java");list.add("后端");System.out.println(list);}
}

类型变量建议使用大写的英文字母，常用的有：E、T、K、V等

E：常用于集合类（如 List、Set），强调泛型参数是容器内的元素。

T：当泛型类或方法不限制具体类型时，常用 T 作为默认类型占位符。

K/V：用于键值对数据结构（如 Map）中，明确区分键和值的类型。

二、泛型接口

泛型接口（Generic Interface） 是通过类型参数化定义的接口，其核心作用是通过类型抽象提高代码的复用性、类型安全性和灵活性。

修饰符 interface 接口名<类型变量，类型变量...>{
}

public interface A<E>{
...
}

示例

对学生数据/老师数据都要进行增删查改操作。

定义一个泛型接口可以接学生或老师对象进行操作，可以实现一个方法操作两个角色。

package GenericityDemo3;public interface Data<T> {
//    void add(Student s);
//    void add(Teacher t);//类型约定死了，，只能存Student或Teacher//利用泛型接口void add(T t);      //此时泛型可以为Teacher也能为Studentvoid delete(T t);void update(T t);T query(int id);
}

（此示例并没有真正实现增删查改操作，只为示范）

package GenericityDemo3;public class Student {
}

package GenericityDemo3;public class Teacher {
}

创造两个类用于实现Data，一个实现老师操作，一个实现学生操作

package GenericityDemo3;public class TeacherData implements Data<Teacher>{//操作老师数据@Overridepublic void add(Teacher teacher) {}@Overridepublic void delete(Teacher teacher) {}@Overridepublic void update(Teacher teacher) {}@Overridepublic Teacher query(int id) {return null;}
}

package GenericityDemo3;public class StudentData implements Data<Student>{//专门操作学生对象@Overridepublic void add(Student student) {}@Overridepublic void delete(Student student) {}@Overridepublic void update(Student student) {}@Overridepublic Student query(int id) {return null;}
}

package GenericityDemo3;public class GenericDemo3 {public static void main(String[] args) {//目标：搞清楚泛型接口的基本应用//需求：项目需要对学生数据/老师数据都要进行增删查改操作StudentData studentData = new StudentData();studentData.add(new Student());      //添加学生数据.对学生操作Student s = studentData.query(1001);}
}

通过泛型接口，可以为不同类型的数据定义统一的处理逻辑，同时避免强制类型转换和运行时类型错误。

三、泛型方法

泛型方法（Generic Method） 是通过在方法签名中声明类型参数来实现的方法级别泛型化。它与泛型类的主要区别在于作用范围：泛型方法的类型参数仅作用于该方法内部，而非整个类。

语法

修饰符<类型变量，类型变量，...>返回值类型 方法名（形参列表）{}

示例

现在我需要一个方法将数组的内容打印出来

package GenericDemo4;public class GenericDemo4 {//目标：理解泛型方法public static void main(String[] args) {//需求：打印任意数组的内容String[] arr1 = {"hello","world","java"};printArray(arr1);Student[] arr2 = new Student[3];//printArray(arr2);//只能接收String类型数组Student s1 = getMax(arr2); printArray2(arr1);getMax(arr2);       //泛型方法，可以接收任意类型的数组,避免强转}public static  void printArray(String[] arr){for (int i = 0; i < arr.length; i++) {System.out.println(arr[i] + " ");}}public static <T> void printArray2(T[] arr){for (int i = 0; i < arr.length; i++) {System.out.println(arr[i] + " ");}}public static <T> T getMax(T[] name){return null;}
}

上述代码有两个方法，一个是printArray一个是printArray2，但printArray有一个缺点就是只能打印字符串数组的内容，若是其他数组则无法接收。因此，我们可以做一个泛型方法即printArray2，它可以接收String数组也可以接收Student数组，实现了一个方法解决多个问题。

四、通配符与上下限

当我们要传的参数为多个集合，每个集合都是继承于某个父类的子类的集合时，我们就可以通过使用通配符来接收不同的子类集合。（注：例如两个集合为ArrayList<Cat>和ArrayList<Dog>，不能用ArrayList<Animal>接收，因为他们本质上是不同的集合，虽然他们的子类继承了同一个父类）

示例

package GenericDemo4;public class Car {
}

package GenericDemo4;public class BYD extends Car{}

package GenericDemo4;public class BMW extends Car{
}

package GenericDemo4;import java.util.ArrayList;public class GenericDemo5 {public static void main(String[] args) {//目标：理解通配符和上下限ArrayList<BYD> byds = new ArrayList<>();byds.add(new BYD());byds.add(new BYD());byds.add(new BYD());//go(byds);           //报错不具备通用性ArrayList<BMW> bmws = new ArrayList<>();bmws.add(new BMW());bmws.add(new BMW());bmws.add(new BMW());go(bmws);}//模拟极品飞车游戏//虽然比亚迪和宝马是Car的子类，但ArrayList<BYD>和ArrayList<BMW>和ArrayList<Car>是不同的，因此不能用多态
//    public static void go(ArrayList<BMW> cars)
//    {
//
//    }//通配符，在使用泛型时代表一切类型public static void go(ArrayList<?> cars){}
}

然而，若是这么写这个方法能接收的集合范围又太大了，连猫和狗都可以进这个开汽车的方法，因此需要使用上下限来加以限制。

? extends Car ?能接收Car或者Car的子类（泛型上限）
? super Car ?能接收Car或者Car的父类（泛型下限）

package GenericDemo4;import java.util.ArrayList;public class GenericDemo5 {public static void main(String[] args) {//目标：理解通配符和上下限ArrayList<BYD> byds = new ArrayList<>();byds.add(new BYD());byds.add(new BYD());byds.add(new BYD());//go(byds);           //报错不具备通用性ArrayList<BMW> bmws = new ArrayList<>();bmws.add(new BMW());bmws.add(new BMW());bmws.add(new BMW());go(bmws);}//模拟极品飞车游戏//虽然比亚迪和宝马是Car的子类，但ArrayList<BYD>和ArrayList<BMW>和ArrayList<Car>是不同的，因此不能用多态
//    public static void go(ArrayList<BMW> cars)
//    {
//
//    }//通配符，在使用泛型时代表一切类型//为了防止将狗，猫等不属于车的类型传入方法，使用泛型的上下限限制//? extends Car ?能接收Car或者Car的子类（泛型上限）//? super Car ?能接收Car或者Car的父类（泛型下限）public static void go(ArrayList<? extends Car> cars){}
}

这样，就能将这个方法限制在接收汽车类的子类了。

五、泛型支持的数据类型

泛型不支持基本的数据类型，即int，double等数据类型，原因是泛型工作在编译阶段，编译结束后系统会进行泛型擦除，所有类型都会转变为Object类型。而Object是对象类型，接收的是对象，数字等类型不是对象，因此不接收基本的数据类型。为了能够兼容基本的数据类型，java的库里添加了包装类，用于将基本数据类型变为对象。

包装类有8种。

int -> Integer char -> Character ，其它的都是首字母大小写。

package GenericDemo5;import java.util.ArrayList;
import java.util.Objects;public class GenericDemo5 {public static void main(String[] args) {//目标：搞清楚泛型和集合不支持基本数据类型，只能支持对象类型（引用类型）//ArrayList<double> list = new ArrayList<>();   //报错，不支持//泛型擦除：泛型工作在编译阶段，等编译后泛型就没用了，所以泛型在编译后都会被擦除。所有类型会恢复为Object类型。//Object是对象类型，不能直接指向某个数，只能指向某个对象。//因此要使用包装类，比如Integer、Double、Character、Boolean等。//包装类的作用：把基本数据类型包装成对象类型。//ArrayList<int> list = new ArrayList<>();//list.add(12);     //12不是对象，报错ArrayList<Integer> list = new ArrayList<>();list.add(12);           //自动装箱，把基本数据类型12包装成Integer对象。int rs= list.get(0);        //自动拆箱，把Integer对象12拆箱成基本数据类型。//把基本数据类型变成包装类对象//手工包装//Integer i = new Integer(12);//从jdk9开始，这个方法被淘汰了（过时）//推荐用valueOf的原因：valueOf方法中缓存了-128~127的数值，重复创建这个范围内的数字时不会创建新对象，而是直接返回缓存中的对象。//缓存对象范围是-128~127，如果超过这个范围，就会创建新的对象。//更优雅，节约内存。Integer i = Integer.valueOf(12);    //此时i为对象，里面存储的是12Integer i2 = Integer.valueOf(12);System.out.println(i == i2);        //ture, 因为i和i2是同一个对象//自动装箱Integer i3 = 12;        //与Integer i = Integer.valueOf(12)一个意思Integer i4 = 12;System.out.println(i3 == i4);//自动拆箱：把包装类型的对象直接给基本类型的数据int i5 = i3;System.out.println(i5);System.out.println("========================================================");//包装类新增的功能//1、把基本类型的数据变成字符串int j=23;String rs1 = Integer.toString(j);System.out.println(rs1+1);      //不是24，说明已经是字符串Integer i6=j;String rs2 = i6.toString();System.out.println(rs2+1);String  rs3 = i6+"";        //直接加""转换为字符串System.out.println(rs3+1);System.out.println("========================================================");//把字符串数值转换成对应的基本数据类型String str = "123";int i1 = Integer.parseInt(str);int i9 = Integer.valueOf(str);System.out.println(i1+1);System.out.println(i9+1);}
}