1 泛型定义和基本使用
泛型是JDK1.5以后才有的， 可以在编译时期进行类型检查，且可以避免频繁类型转化！
@Test
public void test1() {List list = new ArrayList();list.add("ZhangSan");list.add(1);//集合使用 取出元素Object object = list.get(0);System.out.println(object);String str1 = (String) list.get(0);System.out.println(str1);//String str2 = (String) list.get(1);//ClassCastException
}//使用泛型
@Test
public void test2() {//声明泛型集合的时候指定元素的类型List<String> list = new ArrayList<>();list.add("Java");//泛型解决的的是编译时期的报错，提前检查//list.add(1);//会报错String str = list.get(0);System.out.println(str);
}
@Testpublic void test3() {// 两端的数据类型必须要一致List<Object> list1 = new ArrayList<Object>();List<String> list2 = new ArrayList<String>();// 右侧的泛型可以不写List<String> list3 = new ArrayList<>();// 只在右侧写泛型不起作用List list4 = new ArrayList<String>();list4.add(1);// 两边不一致编译时候报错 -----> 红色波浪线// List<Object> list5 = new ArrayList<String>();// 泛型类型必须为引用数据类型// List<int> list6 = new ArrayList<>();}
2 泛型擦除
泛型只在编译时期有效，编译后的字节码文件中不存在有泛型信息！
-
帮助开发者写出正确的代码。
-
虚拟机的向下兼容问题
@Testpublic void test5() {List<String> list1 = new ArrayList<>();List<Integer> list2 = new ArrayList<>();Class clazz1 = list1.getClass();Class clazz2 = list2.getClass();System.out.println(clazz1 == clazz2);System.out.println(clazz1);System.out.println(clazz2);}//泛型擦除:参数都是List list 认为是同一个方法/*public void add(List<Student> list) {}public void add(List<Teacher> list) {}*///'add(List<Student>)' clashes with 'add(List<Teacher>)'; both methods have same erasure
3 泛型方法/泛型类/泛型接口
作用：设计公用的类、方法，对公用的业务实现进行抽取！使程序更灵活！
泛型方法
public class GenericDemo2 {public Student add1(Student student, Teacher teacher) {return null;}public <K,T> K add(K k, T t) {return k;}@Testpublic void test1() {// 使用泛型方法: 在使用泛型方法的时候，确定泛型类型Float result1 = add(1.0f, 1);System.out.println(result1);String result2 = add("abc", 1);System.out.println(result2);}
}
泛型类
不用像泛型方法那样每个方法都要声明。
public class BaseDao<T> {public <K> K save(K k) {return k;}public void add(T t) {}public void update(T t) {}
}@Test
public void test2() {Student student = new Student();BaseDao<Student> baseDao1 = new BaseDao<>();baseDao1.add(student);baseDao1.update(student);Teacher teacher = new Teacher();BaseDao<Teacher> baseDao2 = new BaseDao<>();baseDao2.add(teacher);baseDao2.update(teacher);
}
泛型接口
public interface IBaseDao<T> {void add(T t );void update(T t );
}
//泛型接口类型确定： 在业务实现类中直接确定接口的类型
public class PersonDao implements IBaseDao<Person> {
}
4 泛型关键字
常用的 ？, T, E, K, V, N的含义
我们在泛型中使用通配符经常看到T、F、U、E，K，V其实这些并没有啥区别,我们可以选 A-Z 之间的任何一个字母都可以，并不会影响程序的正常运行。
只不过大家心照不宣的在命名上有些约定:
T (Type) 具体的Java类
E (Element)在集合中使用，因为集合中存放的是元素
K V (key value) 分别代表java键值中的Key Value
N （Number）数值类型
? 表示不确定的 Java 类型
泛型中：
? 在泛型代码中，问号(?)称为通配符，用来表示不确定的 Java 类型
extends 元素的类型必须继承自指定的类
super 元素的类型必须是指定的类的父类
使用<?>通配符，可以使方法更加灵活，可以接受不同类型的 List 列表，同时又不会对List进行修改，保证代码的安全性。
既要限定传递过来的是集合类型，但是又不确定里面类型List<?> list；
public void add1(List<?> list) {}// extends 元素的类型必须继承自指定的类
/**
* list集合只能处理 Double/Float/Integer等类型
* 限定元素范围：元素的类型要继承自Number类 (上限)
* @param list
*/
public void add2(List<? extends Number> list) {
}@Test
public void testGeneric23() throws Exception {List<Double> list1 = new ArrayList<Double>();List<Float> list2 = new ArrayList<Float>();List<Integer> list3 = new ArrayList<Integer>();List<String> list4 = new ArrayList<String>();// 调用add2(list1);add2(list2);add2(list3);//add2(list4);
}/**
* super限定元素范围：必须是String父类,String类也可以 (下限)
* @param list
*/
public void add3(List<? super String> list) {
}@Test
public void testGeneric24() throws Exception {// 调用上面方法，必须传入String的父类List<Object> list1 = new ArrayList<Object>();List<String> list2 = new ArrayList<String>();List<Integer> list3 = new ArrayList<Integer>();//add(list3);
}
5 List和List<?>的区别
ChatGPT 也可能会犯错。请核查重要信息。
这两段代码之间的主要区别在于泛型的使用。让我们仔细看看每段代码，并解释它们的差异。
第一段代码
public void add(List<?> list) {//list.add(1);//Required type: capture of ? | Provided:intfor (Object object : list) {System.out.println(object);}
}
解释
List<?>：这是一个使用通配符?的泛型列表。这表示列表可以包含任何类型的元素，但是我们不能向这个列表添加任何元素（除了null）。- 为什么不能添加元素：由于
List<?>表示一个未知类型的列表，编译器无法确定添加的元素是否与列表的实际类型兼容。因此，添加操作会导致编译错误。 - 遍历元素：我们可以遍历这个列表，并将每个元素作为
Object类型处理，因为我们不知道确切的元素类型。
- 为什么不能添加元素：由于
示例：
public void add(List<?> list) {// 编译错误：不能向未知类型的列表添加元素// list.add(1);// 可以遍历列表并打印元素for (Object object : list) {System.out.println(object);}
}
第二段代码
public void add1(List list) {//list.add(1);//Required type: capture of ? | Provided:intfor (Object object : list) {System.out.println(object);}
}
解释
List（原始类型）：这是一个原始类型的列表，没有使用泛型。这意味着列表可以包含任何类型的元素，且类型检查在编译时被绕过，但在运行时可能导致ClassCastException。- 可以添加元素：尽管没有泛型限制，可以向列表添加元素。然而，这种做法会失去类型安全性。
- 遍历元素：我们可以遍历这个列表，并将每个元素作为
Object类型处理。
示例：
public void add1(List list) {// 可以向原始类型的列表添加元素，但这不安全list.add(1);// 可以遍历列表并打印元素for (Object object : list) {System.out.println(object);}
}
关键区别
-
类型安全性：
List<?>提供类型安全性，不能向列表添加元素，除了null。List是原始类型，没有类型安全性，可以向列表添加任何类型的元素，但这可能会在运行时导致ClassCastException。
-
编译检查：
List<?>在编译时会进行类型检查，确保没有非法的添加操作。List由于没有泛型，编译器无法提供类型检查，这可能导致潜在的运行时错误。
-
可添加元素：
- 在
List<?>中，不能添加元素（除了null）。 - 在
List中，可以添加任何类型的元素。
- 在
总结
List<?>：使用通配符泛型表示未知类型的列表，提供类型安全性，但不能添加元素。List：使用原始类型，没有类型安全性，可以添加任何类型的元素，但可能导致运行时错误。
选择使用哪种类型取决于具体的需求和安全性考虑。对于大多数情况下，使用泛型是推荐的做法，因为它提供了编译时的类型检查，从而提高了代码的安全性和可维护性。
6 全面简单地介绍下Java的泛型及其作用
ChatGPT 也可能会犯错。请核查重要信息。
Java的泛型
泛型是Java编程语言的一项强大特性，它允许你定义和使用带有类型参数的类、接口和方法。泛型提供了编译时的类型检查和代码重用性，减少了类型转换的需要和运行时错误的风险。
主要特性和语法
-
泛型类和接口：
定义包含类型参数的类或接口。public class Box<T> {private T content;public void setContent(T content) {this.content = content;}public T getContent() {return content;} } -
泛型方法：
定义带有类型参数的方法。public class Util {public static <T> void printArray(T[] array) {for (T element : array) {System.out.println(element);}} } -
类型推断：
在调用泛型方法时，编译器可以根据传递的参数推断出类型参数。Box<Integer> intBox = new Box<>(); intBox.setContent(123); Integer content = intBox.getContent(); -
通配符：
使用问号?表示未知类型。public void processList(List<?> list) {for (Object obj : list) {System.out.println(obj);} } -
边界通配符：
限制类型参数的范围，可以是上界或下界。public void processNumbers(List<? extends Number> list) { // 上界通配符for (Number num : list) {System.out.println(num);} }public void addNumbers(List<? super Integer> list) { // 下界通配符list.add(123); } -
泛型限制：
泛型类型不能是基本类型（如int，char等），只能是引用类型（如Integer，String等）。// 正确的写法 List<Integer> list = new ArrayList<>();// 错误的写法 // List<int> list = new ArrayList<>();
泛型的作用
-
类型安全：
泛型提供了编译时的类型检查，防止类型转换错误。例如，使用泛型集合可以确保集合中的所有元素都是指定类型。List<String> list = new ArrayList<>(); list.add("hello"); // list.add(123); // 编译时错误 -
减少类型转换：
使用泛型可以减少显式类型转换的需要，从而使代码更加简洁和可读。List<String> list = new ArrayList<>(); list.add("hello"); String str = list.get(0); // 不需要类型转换 -
代码重用：
泛型使得可以编写通用的类、接口和方法，这些代码可以与不同类型的对象一起工作，提高代码的重用性。public class Pair<T, U> {private T first;private U second;public Pair(T first, U second) {this.first = first;this.second = second;}// getter 和 setter }Pair<String, Integer> pair = new Pair<>("age", 30); -
提高代码可读性：
泛型使得代码更加清晰和可读，因为类型信息明确。// 不使用泛型 List list = new ArrayList(); list.add("hello"); String str = (String) list.get(0); // 类型转换// 使用泛型 List<String> list = new ArrayList<>(); list.add("hello"); String str = list.get(0); // 无需类型转换
总结
Java 的泛型是一种用于定义和使用带有类型参数的类、接口和方法的强大特性。它提供了类型安全、减少类型转换、代码重用和提高代码可读性等诸多优点。在现代 Java 编程中，泛型广泛应用于集合框架和许多库中，极大地增强了语言的灵活性和安全性。
