第十二章：泛型
2021年3月6日
18:38
声明的泛型类型与new对象的泛型类型与声明不同泛型类型的变量之间的关系（闲的）：
|
//泛型的类型是按照声明的变量类型算的 ArrayList<Integer> list = new ArrayList<>(); list.add(123); //此时只能添加Integer类型 //重新赋值的话，原变量的泛型类型也是按照声明的变量类型算的，不管new出来的对象的泛型类型是什么，都是按照声明的变量的泛型类型。同时，赋值给新的变量之后，会按照新声明的变量的泛型类型算。 ArrayList list1 = list; list1.add("abc"); //可以正常添加 ArrayList list2 = new ArrayList<Integer>(); list2.add("String"); //可以正常添加 ArrayList<String> list3 = list2; //可以正常赋值，并添加新类型的数据 list3.add("fff"); list3.add(12); //错误 //不同的类型不能赋值 ArrayList<Integer> list4 = new ArrayList<String>(); //错误 //不同的类型也不能重新赋值，即使new的对象本身没有声明泛型类型 ArrayList<String> list5 = new ArrayList<>(); ArrayList<Integer> list6 = list5; //错误 //有继承关系的类也不行，算是不同的类型。不管是声明大对象小，还是声明小对象大 ArrayList<Student> list7 = new ArrayList<Person>(); //错误 ArrayList<Person> list8 = new ArrayList<Student>(); //错误 ArrayList<Person> list9 = list7; //错误 //没有声明泛型的变量，可以重新赋值给其他声明泛型的变量 //声明泛型的变量，也可以重新赋值给没有声明泛型的变量 ArrayList list10 = new ArrayList(); ArrayList<String> list11 = list10; ArrayList<String> list12 = new ArrayList<String>(); ArrayList list13 = list12;
//总结：new对象的泛型类型对于操作数据没有任何实质影响，主要是靠声明变量位置声明的泛型类型约束的（jdk7的新特性：类型推断） ArrayList<String> a1 = new ArrayList<String>(); ArrayList a2 = a1; ArrayList<Integer> a3 = a2; a1.add("abc"); a2.add(new Person()); a3.add(123);
System.out.println(a3); //[abc, com.atguigu.java.Person@4ee285c6, 123] |
|
//嵌套的泛型结构，两边都有外层泛型类型的情况下，不写内层泛型类型的 ≠ 写内层泛型类型的 //即两边都有外层泛型类型的情况下，内层泛型类型必须完全一样，左右两边都不能省略
理解：内层泛型作为外层泛型的类型实参，可以装任何类的A类和只能装某种类的A类不是相同的类型！
Set s = new HashSet<Map.Entry>(); //正确 Set<Map.Entry> s2 = new HashSet<Map.Entry<String,Integer>>(); //错误 Set<Map.Entry<String,Integer>> s3 = new HashSet<Map.Entry>(); //错误 |
泛型的使用
* 1.jdk 5.0新增的特性
*
* 2.在集合中使用泛型：
* 总结：
* ① 集合接口或集合类在jdk5.0时都修改为带泛型的结构。
* ② 在实例化集合类时，可以指明具体的泛型类型
* ③ 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型。
* 比如：add(E e) --->实例化以后：add(Integer e)
* ④ 注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换
* ⑤ 如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型。
*
* 3.如何自定义泛型结构：泛型类、泛型接口；泛型方法。见 GenericTest1.java
用泛型之前：
问题一：类型不安全
问题二：强转时，可能出现ClassCastException
|
Map<String,Integer> map = new HashMap<String,Integer>(); //jdk7新特性：类型推断 Map<String,Integer> map1 = new HashMap<>(); |
//泛型的嵌套
|
Set<Map.Entry<String,Integer>> entries = map.entrySet(); Iterator<Map.Entry<String, Integer>> iterator = entries.iterator(); |
//泛型类型实参可以是数组
|
ArrayList<int[]> list = new ArrayList<>(); list.add(new int[2]); |
自定义泛型结构：泛型类、泛型接口
* 1. 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：<E1,E2,E3>
* 2. 泛型类的构造器如下：public GenericClass(){}。
而下面是错误的：public GenericClass<E>(){}
* 3. 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
* 4. 泛型不同的引用不能相互赋值。
>尽管在编译时ArrayList<String>和ArrayList<Integer>是两种类型，但是，在运行时只有一个ArrayList被加载到JVM中。
* 5. 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object（一旦显式地指定Object，编译会类型检查，必须按照Object处理）。经验：泛型要使用一路都用。要不用，一路都不要用。
|
List<Object> list1 = null; List<String> list2 = new ArrayList<String>();
show(list1); show(list2);
show1(list1); show1(list2); //编译不通过
public void show(List list){} public void show1(List<Object> list){} |
* 6. 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
* 7. jdk1.7，泛型的简化操作：ArrayList<Fruit> flist = new ArrayList<>();
* 8. 泛型的指定中不能使用基本数据类型，可以使用包装类替换。
* 9. 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。
* 10. 异常类不能是泛型的，不能在try-catch中使用泛型定义
|
//编译不通过 try{
}catch(T t){
} |
* 11. 不能使用new E[]（会报：Type parameter 'E' cannot be instantiated directly）。但是可以：E[] elements = (E[])new Object[capacity];
理解：new E[]是一个具体的操作了，只有一个类就叫E才可以这样去new E[]。E其实是一个变量，一个参数。实例化的时候指明的一个类型而已。
参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。用的时候再强转
|
E elementData(int index) { return (E) elementData[index]; } |
* 12.父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：
l 子类不保留父类的泛型：按需实现
Ø 没有类型 擦除
|
class Father<T1, T2> { } class Son1 extends Father { // 等价于class Son extends Father<Object,Object> } |
Ø 具体类型
|
class Son2 extends Father<Integer, String> { } |
l 子类保留父类的泛型：泛型子类
Ø 全部保留
|
class Son3<T1, T2> extends Father<T1, T2> { } |
Ø 部分保留
|
class Son4<T2> extends Father<Integer, T2> { } |
结论：子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型
|
class Father<T1, T2> { } // 子类不保留父类的泛型 // 1)没有类型 擦除 class Son<A, B> extends Father{ //等价于class Son<A,B> extends Father<Object,Object> } // 2)具体类型 class Son2<A, B> extends Father<Integer, String> { } // 子类保留父类的泛型 // 1)全部保留 class Son3<T1, T2, A, B> extends Father<T1, T2> { } // 2)部分保留 class Son4<T2, A, B> extends Father<Integer, T2> { } |
注意：
|
class SubOrder extends Order<Integer>{} //由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型。 SubOrder sub1 = new SubOrder(); //在调用父类中有泛型的结构时，按照继承时指明的泛型类型 sub1.setOrderT(1122); |
|
class Father<T1,T2>{} //报错是Cannot resolve symbol 'T1'，说明这样的写法，是把子类的泛型传给父类。 class Son4<T2, A, B> extends Father<T1,T2> { } |
继承重写方法相关：
|
①子类用泛型类型重写父类没有用泛型的方法，不构成重写，也不报错。 //但是如果子类对象声明的泛型类型和父类方法的参数一样，调用时会报错 //不明确的方法调用：Ambiguous method call
②子类继承时提供了父类的泛型具体类型(比如String)时，重写父类带泛型参数的方法必须用相同的类型(String) //不能用子类的泛型，会报错误：冲突，两个方法在类型擦除后，具有相同的原生类型参数列表，但是也不能覆盖另一个方法
③子类继承时没有提供父类的泛型具体类型时，重写父类带泛型参数的方法必须用Object //不能用子类的泛型，会报错误：冲突，两个方法在类型擦除后，具有相同的原生类型参数列表，但是也不能覆盖另一个方法 class Car<T1,T2>{ public T1 getCar(T1 t){ return t; } public void getPrice(String d){} }
class Audi<E> extends Car<String,Integer>{ //报错：clash, both methods have same erasure, yet neither overrides the other public E getCar(E e){ return null; } //构成重写 public String getCar(String s){ return s; }
public void getPrice(E e){
} } class BYD<E> extends Car{ //报错：clash, both methods have same erasure, yet neither overrides the other public E getCar(E e){ return e; } //构成重写 public Object getCar(Object o){ return o; } } public class OverrideTest { @Test public void test1(){ Audi<String> a = new Audi<>(); a.getPrice("abc"); //报错！不明确的方法调用：Ambiguous method call Audi<Integer> b = new Audi<Integer>(); b.getPrice("abc"); b.getPrice(123); //不冲突就没事，可以正常识别 } } |
泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
//换句话说，泛型方法所属的类是不是泛型类都没有关系。
//泛型方法可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。
//前面要写上<E>，表明E是一个泛型，而不是一个类名。E要写在public(static)的后面
[访问权限] <泛型> 返回类型 方法名([泛型标识 参数名称]) 抛出的异常
|
public static <E> List<E> copyArrayToList(E[] arr){ ArrayList<E> list = new ArrayList<>(); for(E e : arr){ list.add(e); } return list; } |
泛型在继承方面的体现
虽然类A是类B的父类，但是 G<A> 和 G<B> 二者不具备子父类关系，二者是并列关系。
|
List<Object> list1 = null; List<String> list2 = new ArrayList<String>(); //此时的list1和list2的类型不具有子父类关系 //编译不通过 // list1 = list2;
show(list1); // show(list2); //编译不通过 public void show1(List<Object> list){ } |
补充：类A是类B的父类，A<G>是B<G>的父类
|
List<String> list2 = null; ArrayList<String> list3 = null; // list3 = list2;//编译错误 list2 = list3; //等效于 List<String> list4 = new ArrayList<Strirng>(); |
通配符的使用
通配符：?
|
public void test3(){ List<Object> list1 = null; List<String> list2 = null; List list3 = null;
List<?> list = null; list = list1; list = list2; list = list3; // list1 = list; //错误，List<?>不等同于List<Object> // list2 = list; //错误 list3 = list;
//编译通过 print(list1); print(list2); //List<?>为形参的对象，也可以传入没有使用通配符的对象 print(list3);
List<String> list31 = new ArrayList<>(); list31.add("AA"); list31.add("BB"); list31.add("CC"); list = list31; //添加(写入)：对于List<?>就不能向其内部添加数据。 //除了添加null之外。 // list.add("DD"); //错误 // list.add('?'); //错误 list.add(null);
//获取(读取)：允许读取数据，读取的数据类型为Object。 Object o = list.get(1); System.out.println(o); } |
|
public void print(List<?> list){ //list.iterator()返回的对象也用Iterator<?> iterator接收 Iterator<?> iterator = list.iterator(); while(iterator.hasNext()){ //iterator.next()返回的对象不能用 ? 接收！！要用Object obj接收 Object obj = iterator.next(); System.out.println(obj); } } |
有限制条件的通配符的使用。
? extends A:
? super A:
|
public void test4(){ List<? extends Person> list1 = null; List<? super Person> list2 = null;
List<Student> list3 = new ArrayList<Student>(); List<Person> list4 = new ArrayList<Person>(); List<Object> list5 = new ArrayList<Object>();
list1 = list3; list1 = list4; // list1 = list5; //编译不通过
// list2 = list3; //编译不通过 list2 = list4; list2 = list5;
//读取数据： list1 = list3; Person p = list1.get(0); //最大是Person，所以可以用Person装 //编译不通过 // Student s = list1.get(0);
list2 = list4; Object obj = list2.get(0); //最小是Person，没有最大限制，所以只能用Object装 //编译不通过 // Person p1 = list2.get(0);
//写入数据 //编译不通过，没有最小限制，所以写入谁都可能有比它小的，所以不能写入 // list1.add(new Person()); // list1.add(new Student());
//编译通过，最小是Person，所以Person和Person的子类都可以写入，多态的形式 list2.add(new Person()); list2.add(new Student()); } |
注意：给Map用put()做修改value操作的时候，要先用containsKey()判断是否有对应的key，有的话再put()！
不然没有数据的话就新增了一条数据，不符合业务逻辑！
2021年3月8日18:15:32 完结。注意加粗，结尾拉到上面
结尾
使用 Microsoft OneNote 2016 创建。 版权所有：古木苏