当前位置：首页 > news >正文

泛型..

news 文章来源：https://blog.csdn.net/m0_71299382/article/details/135736479 2024/11/30 0:48:01

1.泛型

所谓泛型在类定义处是一种类型参数(我们平常所见到的参数指的就是方法中的参数他接收有外界传递来的值然后在方法中进行使用) 在类内部的话则充当一种占位符并且还提高了代码的复用率
何以见得提高了代码的复用率其实就是通过对比使用了泛型技术和没有使用泛型技术之间的区别：
以下是没有使用泛型技术的案例

public class Student1 {// 第一个学生类他的分数接收的是一个浮点类型的数据double score;// 定义getter、setter方法void setScore(double score){this.score = score;}double getScore(){return score;}
}
public class Student2 {// 这个学生类接收的是字符串类型的分数String score;// 定义getter、setter方法void setScore(String score){this.score = score;}String getScore(){return score;}
}
public class Student3 {// 第三个学生类的分数就定义为整型int score;// 定义相关的getter、setter方法void setScore(int score){this.score = score;}int getScore(){return score;}
}

从以上代码中我们可以看出定义了三种不同类型的分数就要定义三份逻辑相似的代码如果分数的类型规模一旦庞大起来那么其实效率是十分低下的
现在引入了泛型技术以后就不会出现以上这种局面并且会提高同一份代码的复用率

public class Student<T>{// 泛型是一种类型参数 有外界的实参所决定 并且可以在类中使用T score;// 定义一个getter、setter方法void setScore(T score){this.score = score;}T getScore(){return score;}
}

我们可以在主函数中测试一下这个代码的正确性

public class Main {public static void main(String[] args) {// 我们来试用一下泛型好不好用吧Student<String> s1 = new Student<>();Student<Integer> s2 = new Student<>();Student<Double> s3 = new Student<>();s1.setScore("优秀");s2.setScore(100);s3.setScore(99.5);System.out.println(s1.getScore());System.out.println(s2.getScore());System.out.println(s3.getScore());}}

从结果可以看出这个泛型类型是写的很成功的并且从中我们还能够得知从java7开始右边<>内就可以不用写出具体的泛型了

而且我们的泛型名称是有命名建议的：
T Type
E Element
K Key
N Number
V Value
S、U、V 当你想要表示连续类型中的第二个、第三个、第四个泛型的时候的命名建议

类名后面不仅可以支持一个泛型也可以支持多个泛型

public class Student<N, S>{private N no;private S score;public Student(N no, S score){this.no = no;this.score = score;}
}
public class Main {public static void main(String[] args) {Student<Integer, Double> s = new Student<>(1, 100.0);}
}

何为泛型类型？其实就指的是哪些使用了泛型的类或者接口
比如一些诸如java.util.Comparator、java.util.Comparable之类的接口

2.泛型类型的继承

我们从前面的多态都知道如果类或者接口之间存在父子关系的话那么让父类引用指向子类对象是可以编译成功的(子类引用也可以指向父类对象前提是要进行强制转换)
以下的案例中从结果可以明显发现strBox和intBox不存在父子关系 objBox和strBox之间不存在父子关系
有些人可能会以泛型的继承关系来作为泛型类型的继承关系那好我们可以超这个方向继续往下想如果结论果真是如此的话那么第一对关系肯定不符合因为String和Integer压根不存在父子关系只有第二对中的String和Object之间存在父子关系好接着往下想如果是父子关系的话多态是可以编译通过也就是说 strBox和objBox指向的是同一个对象然后我通过objBox设置了所指对象的element值他的类型为Object类型然后通过strBox获取所指对象的element值并且通过一个String变量进行获取但是我们可以清楚的发现由于之前element已经被设置为Object类型所以导致Object赋值给了String 其实如果没有强制转换的话这个语句是不能通过编译的但是实际上这个语句是编译通过的所以说我们刚才的strBox和objBox之间是不存在父子关系的

public class Main {public static void main(String[] args) {Box<String> strBox = new Box<>();Box<Integer> intBox = new Box<>();Box<Object> objBox = new Box<>();strBox = intBox;// errorobjBox = strBox;// error// 如果上面代码是正确的话 那么思考一下下面的代码objBox.setElement(new Object());String str = strBox.getElement();}
}

所以说下面这张图其实清楚的阐明了Number和Integer以及Box之间的关系
在这里插入图片描述

接着一个案例
在这里插入图片描述

我们都知道jdk中存在这这样如图所示的这样一种关系
由于上述各种接口或者类之间存在这父子关系所以以下的代码其实都是可以编译通过的

public class Main {public static void main(String[] args) {Iterable<String> it = null;Collection<String> col = null;List<String> li = null;ArrayList<String> al = null;it = col;col = li;li = al;}
}

但是如果是以下代码的话就不能够编译通过了
假设我们的List和ArrayList都是自定义的(就是非jdk源码是允许的) 并且他们类或者接口的结构是一样的那么如果按照刚才那个反例来看的话那么list和al是父子关系那么list和al所指对象是一致的(假设list的泛型为Object al的泛型是String) 并且我通过list设置所指对象的no 这个no就是Object类型的然后通过al获取所指对象的no 并且通过String变量保留而Object是不能够在没有强制转换的前提下完成这个赋值的但是实际上这个赋值操作是允许的所以说list和al其实不是父子关系

public class Main {public static void main(String[] args) {List<Object> list = null;ArrayList<String> al = null;list = al;// error}
}

我可以总结一下就是说
当泛型不一致的话那么泛型类型就一定不存在父子关系
当泛型一致的话那么泛型类型也不一定存在父子关系只有当泛型类型是有继承或者实现关系的话那么泛型类型才有父子关系

前面说到泛型可以支持连续多个的当我们两个类或者接口中的第一个泛型是一致的并且子类可以存在第二个泛型的时候那么这时候子类和父类之间是存在父子关系的

public interface MyList<E, T> extends List<E> {void setNo(T no);
}
public class Main {public static void main(String[] args) {List<String> li = null;MyList<String, Integer> ml1 = null;MyList<String, Double> ml2 = null;MyList<String, String> ml3 = null;li = ml1;li = ml2;li = ml3;}
}

从结果显示编译是通过的说明其实上述的这种操作是完全被允许的

3.原始类型

何为原始类型其实就是没有为泛型提供一个具体的类型
在这里插入图片描述
从上图中我们想说的是：
当我们使用了原始类型的时候那么编译器就会警告我们这是一个原始类型发出rawtypes警告
当我们将非原始类型赋值给原始类型的时候编译器是很正常的
但是当我们将原始类型赋值给非原始类型的时候编译器会发出unchecked警告
我们对于以上这些由编译器发出的警告可以通过@SuppressWarnings这个注解进行消除

public class Box<T>{private T no;public T getNo(){return no;}public void setNo(T no){this.no = no;}
}
public class Main {public static void main(String[] args) {Box box = new Box();box.setNo(new Object());Object o = box.getNo();}
}

通过上面这段代码我想说的是如果是原始类型的话那么当我们进行getter和setter方法的时候所涉及到的no都是Object类型的那么我们可能会有一个疑惑就是这不是和泛型为Object的泛型类型一样吗那么这两个等价吗其实他们两者是有着本质的区别的：
一个是原始类型一个是非原始类型只是原始类型的getter和setter方法中涉及到的no都是Object类型的

4.泛型方法

使用了泛型的方法但是这边有一个误区是在泛型类型中如果方法的返回值或者参数为泛型的话那么不是泛型方法真正我们去判断一个类或者一个方法是否为泛型类型或者泛型方法的依据是：他们的声明位置处是否有< T>标志泛型方法的标志一般都是写在返回值之前

现在有一个需求是：
我们想要将setter方法为学生对象赋值的操作封装在一个方法中

public class Student<N, S>{private N no;private S score;public N getNo(){return no;}public void setNo(N no){this.no = no;}public S getScore(){return score;}public void setScore(S score){this.score = score;}
}
public class Main {public static void main(String[] args) {Student<Integer, Integer> stu1 = new Student<>();int no1 = 1;int score1 = 90;set(stu1, no1, score1);Student<String, String> stu2 = new Student<>();String no2 = "2";String score2 = "100";set(stu2, no2, score2);// error}public static void set(Student<Integer, Integer> stu, Integer no, Integer score){stu.setNo(no);stu.setScore(score);}public static void set(Student<String, String> stu, String no, String score){stu.setNo(no);stu.setScore(score);}
}

set(stu2, no2, score2)立马编译失败这是因为我们set方法中的泛型位置处写死了不能够接收任意的类型所以我们应该将set方法设置为泛型方法

public class Main {public static void main(String[] args) {Student<Integer, Integer> stu1 = new Student<>();int no1 = 1;int score1 = 90;set(stu1, no1, score1);Student<String, String> stu2 = new Student<>();String no2 = "2";String score2 = "100";set(stu2, no2, score2);System.out.println(stu1.getNo());System.out.println(stu2.getNo());}public static <N, S> void set(Student<N, S> stu, N no, S score){stu.setNo(no);stu.setScore(score);}
}

从结果来看这种做法的确完成了我们的需求
但是其实我们想使用泛型类型一样我们在使用泛型方法的时候也可以写明这个方法所需的泛型

public class Main {public static void main(String[] args) {Student<Integer, Integer> stu1 = new Student<>();int no1 = 1;int score1 = 90;Main.<Integer, Integer>set(stu1, no1, score1);Student<String, String> stu2 = new Student<>();String no2 = "2";String score2 = "100";<String, String>set(stu2, no2, score2);// errorSystem.out.println(stu1.getNo());System.out.println(stu2.getNo());}public static <N, S> void set(Student<N, S> stu, N no, S score){stu.setNo(no);stu.setScore(score);}
}

但是<String, String>set(……);这种写法肯定是编译失败的
就算你不写完整版本的泛型方法那么编译器也会自动推断出泛型方法调用时的泛型类型

以下是一个案例：
在这里插入图片描述
这个案例中我们在声明addBox方法的时候没有写死泛型所以我们可以不用写出针对不同类型组合的多份类似代码而是通过引入泛型技术做到代码复用率的提高

1.类型推断

前面我们在调用类型方法的时候有简化版本和完整版本我们知道简化版本编译器会根据你传递的参数类型来获悉你的泛型具体是什么但是如果一个类型方法不需要传递参数的话那么编译器应该依据什么推断出泛型方法的泛型呢其实除了根据参数得知泛型也可以根据所调用的方法的返回值来获悉
在这里插入图片描述

2.构造方法

除了普通方法可以使用泛型技术以外构造方法其实也可以使用这项技术
在这里插入图片描述
可以看到其实我也没有写明传递给泛型的具体类型是什么编译器会自动根据我传递的参数类型进行推断得到具体的泛型

3.细节

在泛型类型中静态方法是不能够使用来自泛型类型的泛型的原因在于：
静态方法可以不通过实例调用但是泛型是需要通过创建实例来进行具体赋值的泛型没有具体的值那么你就无法在类中去使用这个泛型所以泛型其实和实例是相关联的而静态方法可以不和实例关联

但是你非要在静态方法中使用泛型的话那么你可以将这个方法升级为泛型方法那么无论你在调用的时候写的是完整版本还是简化版本编译器都可以知道你泛型的具体类型你就可以安心在静态方法中去使用这个泛型了

5.限制类型参数

我们可以利用extends对类型参数进行设限比如< T extends A>
extends可以后接接口名或者类名代表T必须是A类型或者继承、实现A
在这里插入图片描述
以上的案例中我们可以传递Integer给类型参数但是不能够传递String 而且当我们传递Integer后可以调用父类的实例方法intValue

而且不仅仅可以添加一个限制还可以添加多个限制
比如<T extends A & B & C>

但是多个限制存在一些细节：
1.和普通的继承一样他仅支持单继承也就是只能够继承一个类
2.和普通的接口一样他支持多实现也就是他能够实现多个接口
3.和普通的继承必须写在实现之前一样他也遵循这个规定
4.不能够写成<T extends A | B | C>这种形式的因为如果同时满足了A和B的话可能会产生歧义(因为A | B | C限制了T只能满足其中一种那么如果同时满足了两种的话那么到底是满足哪一种呢这是存在歧义的)

现在有这么一个需求：
就是想要获取一个任意类型的数组中的最大值但是如果想要获取最大值的话那么这个类型必须具备可比较性也就是有这自定义的比较逻辑所以说这个类型必须实现Comparable接口

public class Student implements Comparable<Student>{private int age;public Student(int age){this.age = age;}@Overridepublic String toString() {return "[" + age + "]";}@Overridepublic int compareTo(Student o) {// 但是如果参数为空的话 那么一定说明调用者比较大if(o == null)return 1;return age - o.age;// 如果返回值如此的话 那么说明年龄大的Student较大}
}
public class Main {public static void main(String[] args) {Integer[] is = {11, 22, 33};System.out.println(getMax(is));// 33Double[] ds = {11.1, 22.2, 33.3};System.out.println(getMax(ds));// 33.3Student[] ss = {new Student(11), new Student(22), new Student(33)};System.out.println(getMax(ss));// 第三个Student类}// 要获取各种类型的数组中的最大值的话 那么需要定义泛型方法才行static <T extends Comparable<T>> T getMax(T[] array){// 如果数组为空或者数组长度为0的话 那么就不执行任何操作if(array == null || array.length == 0)return null;// 设置最大值的初始值为数组首元素T max = array[0];// 然后和剩余的元素挨个比较 如果元素有较大值的话 那么就更新max值for(int i = 1; i < array.length; ++i){// 如果当前的元素为空的话 那么就继续比较下一个元素if(array[i] == null)continue;// 如果当前元素大于max值的话 那么就更新max值if(array[i].compareTo(max) > 0)max = array[i];}return max;}
}

而且需要注意的一点是：你不能够将max值作为调用者因为如果首元素是空的话那么最后最大值也只能够是空即使你有更大的值的话

但是如果你的元素没有提供比较逻辑的话那么Arrays.sort是无法对你的数组进行比较的

public class Student{private int age;public Student(int age){this.age = age;}@Overridepublic String toString() {return "[" + age + "]";}
}
public class Main {public static void main(String[] args) {Student[] ss = {new Student(11), new Student(22), new Student(33)};Arrays.sort(ss);System.out.println(Arrays.toString(ss));}
}

结果会抛出ClassCastException异常因为你的元素没有具备可比较性换句话说就是你的元素类型没有实现Comparable接口继而没有实现其中的compareTo方法

但是由于我的Arrays.sort方法可以接收另外一个参数换做比较器通过比较器其实我们也可以在元素自身没有具备可比较性的基础上是元素具备可比较性就是设置Comparator接口中的compare方法

public class Student{private int age;public Student(int age){this.age = age;}public void setAge(int age){this.age = age;}public int getAge(){return age;}@Overridepublic String toString() {return "[" + age + "]";}
}
public class Main {public static void main(String[] args) {Student[] ss = {new Student(11), new Student(22), new Student(33)};Arrays.sort(ss, new Comparator<Student>() {@Overridepublic int compare(Student o1, Student o2) {return o1.getAge() - o2.getAge();}});System.out.println(Arrays.toString(ss));}
}

从打印结果来看其实他也可以完成对我们的Student数组的排序操作而且排序结果为升序排序

并且我们如果同时定义了两套排序规则分别来源于自身具备的比较逻辑和比较器中的比较逻辑那么后者会覆盖前者称为我们比较过程中的比较逻辑

public class Student implements Comparable<Student>{private int age;public Student(int age){this.age = age;}public void setAge(int age){this.age = age;}public int getAge(){return age;}@Overridepublic String toString() {return "[" + age + "]";}@Overridepublic int compareTo(Student o) {if(o == null)return 1;return age - o.age;}
}
public class Main {public static void main(String[] args) {Student[] ss = {new Student(11), new Student(22), new Student(33)};Arrays.sort(ss, new Comparator<Student>() {@Overridepublic int compare(Student o1, Student o2) {return o2.getAge() - o1.getAge();}});System.out.println(Arrays.toString(ss));}
}

从打印结果来看可知比较器的比较逻辑确实覆盖了自身具备的比较逻辑

并且如果采用的是比较器的方式的话那么可以继续简化原因在于Comparator接口是一个函数式接口所以我们可以将匿名类简化成Lambda表达式

public class Student implements Comparable<Student>{private int age;public Student(int age){this.age = age;}public void setAge(int age){this.age = age;}public int getAge(){return age;}@Overridepublic String toString() {return "[" + age + "]";}@Overridepublic int compareTo(Student o) {if(o == null)return 1;return age - o.age;}
}
public class Main {public static void main(String[] args) {Student[] ss = {new Student(11), new Student(22), new Student(33)};Arrays.sort(ss, (o1, o2) -> o2.getAge() - o1.getAge());System.out.println(Arrays.toString(ss));}
}

但是如果我现在的需求改动了一下变成了数组元素是Student类但是他比较逻辑中比较的对象是泛型那么应该怎么重置Student类
现在的年龄变成了泛型的话为了使得所有类型都有比较逻辑具有可比较性不止是那些内置的Integer、Double有比较逻辑我们需要重置一下比较逻辑也就是让泛型实现Comparable 并且要让我们的比较逻辑更为健壮一点就是增加判空操作

public class Student<T extends Comparable<T>> implements Comparable<Student<T>>{private T age;public Student(T age){this.age = age;}public void setAge(T age){this.age = age;}public T getAge(){return age;}@Overridepublic String toString() {return "[" + age + "]";}@Overridepublic int compareTo(Student<T> o) {if(o == null)return 1;if(age != null)return age.compareTo(o.age);return o.age == null ? 0 : -1;}
}
public class Main {public static void main(String[] args) {Student[] ss = {new Student<>(11), new Student<>(22), new Student<>(33)};System.out.println(Arrays.toString(ss));}
}

6.通配符

在泛型中 ?表示通配符
通配符用作变量类型、返回值类型的类型参数
而且不能用作泛型方法调用、泛型类型实例化、泛型类型定义时的类型参数、泛型方法声明时的类型参数

public class Main {public static void main(String[] args) {Main.<?>test();// error}public static <T> void test(){}
}

public class Person<T> {
}
public class Main {public static void main(String[] args) {Person<?> p = new Person<?>();// 左边允许 右边error}
}

public class Person<?> {// error}

1.通配符–上界

上界顾名思义就是：保证<? extends xxx>中?是xxx或者xxx的子类型
我们可以通过extends设置参数的上界

现在我有一个这样的需求：
我想要设置一个参数能够接收不同的泛型类型

public class Main {public static void main(String[] args) {Box<Integer> box1 = new Box<>();Box<String> box2 = new Box<>();Box<Object> box3 = new Box<>();showBox(box1);// errorshowBox(box2);// errorshowBox(box3);// ok}public static void showBox(Box<Object> box){}
}

可以看到上述解决方案肯定是不可取的因为不能因为泛型存在父子关系就简单得出泛型类型存在父子关系这其实是错的

public class Main {public static void main(String[] args) {Box<Integer> box1 = new Box<>();Box<String> box2 = new Box<>();Box<Object> box3 = new Box<>();showBox(box1);// okshowBox(box2);// okshowBox(box3);// ok}public static <T> void showBox(Box<T> box){}
}

将静态方法升级为泛型方法这就可以完成上述需求了

public class Main {public static void main(String[] args) {Box<Integer> box1 = new Box<>();Box<String> box2 = new Box<>();Box<Object> box3 = new Box<>();showBox(box1);// okshowBox(box2);// okshowBox(box3);// ok}public static void showBox(Box<?> box){}
}

同样的采用通配符的方式也能够完成接收不同泛型类型的需求

通配符和一般的泛型是有区别的：

public class Main {public static void main(String[] args) {Box<Integer> box1 = new Box<>();Box<String> box2 = new Box<>();Box<Object> box3 = new Box<>();Box<? extends Number> box4 = new Box<>();Box<Number> box5 = new Box<>();box4 = box1;// okbox5 = box1;// error}
}

从中我们可以知道使用通配符可以定义一些模糊的类型但是泛型的话必须是具体化的东西才行正是通配符的这个特性使得上述语句成立

现在还有一个需求：
就是利用通配符完成求和操作并且参与求和的元素必须都是数值才行可以是浮点数也可以是整数(只要你的类型是Number的子类型或者同等类型的话就可以保证这是数值)

public class Main {public static void main(String[] args) {List<Integer> is = Arrays.asList(11, 22, 33);System.out.println(sum(is));// 66.0List<Double> ds = Arrays.asList(11.1, 22.2, 33.3);System.out.println(sum(ds));// 66.6}public static double sum(List<? extends Number> list){double sum = 0.0;for(Number num: list){sum += num.doubleValue();}return sum;}
}

2.通配符–下界

下界顾名思义就是<? super xxx>中?必须是xxx或者xxx的父类型
我们可以通过super设置参数的下界

public class Main {public static void main(String[] args) {List<Integer> l1 = null;List<Number> l2 = null;List<? super Integer> l3 = null;List<? super Number> l4 = null;testLower(l1);// oktestLower(l2);// oktestLower(l3);// oktestLower(l4);// ok}public static void testLower(List<? super Integer> list){}
}

我们现在有一个需求：
向数组中添加元素

public class Main {public static void main(String[] args) {List<Integer> is = new ArrayList<>();addNumber(is);System.out.println(is);List<Number> ns = new ArrayList<>();addNumber(ns);System.out.println(ns);}public static void addNumber(List<? super Integer> list){for(int i = 0; i < 10; ++i){list.add(i);}}
}

从结果可以知道符合预期

3.通配符–无限制

?什么类型都可以传递

public class Main {public static void main(String[] args) {Box<Integer> box1 = null;Box<String> box2 = null;Box<Double> box3 = null;Box<Object> box4 = null;Box<? extends Object> box5 = null;Box<? super Object> box6 = null;test(box1);// oktest(box2);// oktest(box3);// oktest(box4);// oktest(box5);// oktest(box6);// ok}public static void test(Box<?> box){}
}

4.通配符–继承

这个图的记忆方式：就是小范围继承自大范围
在这里插入图片描述

5.通配符–注意

现在有一个需求：
就是打印任意类型的List中的所有元素

public class Main {public static void main(String[] args) {List<Integer> is = Arrays.asList(11, 22, 33);printList(is);// okList<Double> ds = Arrays.asList(11.1, 22.2, 33.3);printList(ds);// ok}public static void printList(List<?> list){for(Object obj: list){System.out.print(obj + " ");}System.out.println();}
}

结果显示可以满足需求

编译器有一个特点就是他在编译的过程中必须要知道类型参数的确切值否则就会报错
所以他在解析List< E>.set(int index, E element)的时候由于E位置处为通配符? 无法确定E的真实类型所以报错了
但是代码提示处这个E他提示为Object类型这其实是因为他不知道这个具体的类型是什么但是事实是不管是什么类型都是Object类型只是具体就是不知道属于什么类型

public class Main {public static void main(String[] args) {}void foo(List<?> list){Object obj = list.get(0);// oklist.set(0, obj);// errorlist.set(0, list.get(0));// error}
}

但是你实在是想要foo方法中的内容全部都编译通过的话有一种做法就是定义一个结构类似的泛型方法然后让foo调用他即可

public class Main {public static void main(String[] args) {}void foo(List<?> list){fooHelper(list);}<T> void fooHelper(List<T> list){T obj = list.get(0);list.set(0, obj);list.set(0, list.get(0));}
}

还有一个细节就是平常的类型参数是不能使用super关键字只能使用extends 只有通配符才可以同时使用super以及extends两个关键字

7.泛型的使用限制

1.泛型不能够传递基本类型只能够使用引用类型

public class Main {public static void main(String[] args) {Map<Character, Integer> map = new HashMap<>();// okMap<char, int> map2 = new HashMap<>();// error}
}

2.泛型不能够实例化

public class Student<E> {public void add(){E element = new E();// error}
}

但是如果非要实例化也不是不行可以通过Class.newInstance间接做到实例化需求

public class Student<E> {public void add(Class<E> cls) throws Exception {E e = cls.newInstance();// ok}
}

我们从源码中可以看出newInstance的返回值是Class的泛型E 但是具体的原理我是不知情的???
3.不能够定义类型为类型参数的静态变量(也不能用于静态方法上原因是一致的)
原因在于：静态变量可以不和实例挂钩但是类型参数必须和实例挂钩

public class Student<E> {private static E age;// error
}

4.不能创建带有泛型的数组

public class Main {public static void main(String[] args) {Student<Integer>[] ss = new Student<>[4];// errorStudent<Integer>[] ss2 = new Student[4];// ok}
}

5.下面的重载是不允许的

public class Main {public static void main(String[] args) {Student<Integer>[] ss = new Student<>[4];// 右边error 但是左边ok}public static void test(Student<? extends String> box){}public static void test(Student<? extends Integer> box){}
}

public class Main {public static void main(String[] args) {Student<Integer>[] ss = new Student<>[4];// 右边error 但是左边ok}public static void test(Student<String> box){}public static void test(Student<? extends Integer> box){}
}

public class Main {public static void main(String[] args) {Student<Integer>[] ss = new Student<>[4];// 右边error 但是左边ok}public static void test(Student<String> box){}public static void test(Student<Integer> box){}
}

6.不能够自定义带反省的异常

public class MyException<T> extends Exception{//error}

7.catch的异常类型不能使用类型参数

public class MyException<T>{void add(){try{System.out.println("add");}catch(T t){// errorSystem.out.println("哈哈");}}<E> void remove(){try{System.out.println("remove");}catch(E e) {// errorSystem.out.println("呵呵");}}
}

8.抛出的异常可以是类型参数

public class MyException<T extends Exception>{public void test() throws T{// ok}
}