1-泛型的使用

1. 为什么要有泛型

首先看一段代码， 没有泛型的时候，对于一个List，我们可以随意添加任意类型的对象，相比数组，只能添加某一种类型的数据，这其实是List的弊端。

什么类型都可以添加，造成了数据的混乱，不便于管理和维护。

1. public class ArrayListTest {

2.     public static void main(String[] args) {

3.         ArrayList list = new ArrayList();

4.         list.add(111);

5.         list.add("ylaihui");

6.         list.add(new Date());

7.     }

8. }

对List增加了标签（也就是泛型）之后， 对可添加的数据进行了约束，使得更加规范，在IDEA编译器中，我们发现对ArrayList增加了泛型后， 添加的数据类型不匹配，编译都不能通过。Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮。

1. //ArrayListTest1.java

2. package com.ylaihui.generic;

4. import java.util.ArrayList;

5. import java.util.Date;

7. public class ArrayListTest1 {

8.     public static void main(String[] args) {

9.         ArrayList<String> strs = new ArrayList<>();

10.         // 编译时就对类型进行检查，保证了数据的安全和一致性

11.         strs.add(111); //Required type: String Provided: int

12.         strs.add(new Date()); 

13.     }

14. }

泛型就是一个标签，一个类型参数。类型不能为基本数据类型，需要是Object 体系的类类型。

集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象， 所以在JDK1.5之前只能把元素类型设计为Object， JDK1.5之后使用泛型来解决。 为这个时候除了元素的类型不确定， 其他的部分是确定的， 例如关于这个元素如何保存， 如何管理等是确定的， 因此此时把元素的类型设计成一个参数， 这个类型参数叫做泛型。 Collection<E>， List<E>， ArrayList<E> 这个<E>就是类型参数， 即泛型

 所谓泛型， 就是允许在定义类、 接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。 这个类型参数将在使用时（例如，继承或实现这个接口， 用这个类型声明变量、 创建对象时） 确定（即传入实际的类型参数， 也称为类型实参） 。

 从JDK1.5以后， Java引入了“参数化类型（ Parameterized type） ” 的概念，允许我们在创建集合时再指定集合元素的类型， 正如： List<String>， 这表明该List只能保存字符串类型的对象。

 JDK1.5改写了集合框架中的全部接口和类， 为这些接口、 类增加了泛型支持，从而可以在声明集合变量、 创建集合对象时传入类型实参。

2. 集合中使用泛型

① 集合接口或集合类在jdk5.0时都修改为带泛型的结构。

② 在实例化集合类时，可以指明具体的泛型类型，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型。比如：List 中的方法 add(E e) ， 实例化以后：add(Integer e)

④ 注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，使用包装类替换

⑤ 如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型。

1. //GenericTest1.java

2. package com.ylaihui.generic;

3. import org.junit.Test;

4. import java.util.*;

5. public class GenericTest1 {

7.     @Test

8.     public void test1() {

9.         ArrayList<Double> ds = new ArrayList<>();

10.         ds.add(11.11);

11.         ds.add(22.22);

12.         // 确定了类型，不需要将Object类型转换其他类型

13.         Iterator<Double> iterator = ds.iterator();

14.         while (iterator.hasNext()) {

15.             System.out.println(iterator.next());

16.         }

17.     }

19.     @Test

20.     public void test2() {

21.         HashMap<String, Integer> map = new HashMap<>();

22.         map.put("ylaihui", 111);

23.         map.put("ylai", 222);

24.         // 确定了类型，更加方便、安全的操作集合数据

25.         Set<Map.Entry<String, Integer>> entries = map.entrySet();

26.         Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();

27.         while (iterator.hasNext()) {

28.             Map.Entry<String, Integer> next = iterator.next();

29.             System.out.println(next.getKey() + ":" + next.getValue());

30.         }

31.     }

32. }

3. 自定义泛型类、接口

如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型

要求：如果定义了类是带泛型的，建议在实例化时要指明类的泛型。

1. //GenericTest2.java

2. package com.ylaihui.generic;

3. class User<T>{

4.     int id;

5.     String name;

6.     T info;

7.     public int getId() {

8.         return id;

9.     }

10.     public void setId(int id) {

11.         this.id = id;

12.     }

13.     public String getName() {

14.         return name;

15.     }

16.     public void setName(String name) {

17.         this.name = name;

18.     }

19.     public T getInfo() {

20.         return info;

21.     }

22.     public void setInfo(T info) {

23.         this.info = info;

24.     }

25.     public User(int id, String name, T info) {

26.         this.id = id;

27.         this.name = name;

28.         this.info = info;

29.     }

30.     public User() {

31.     }

32. }

34. public class GenericTest2 {

35.     public static void main(String[] args) {

36.         User user = new User();

37.         //如果定义了泛型类，实例化时没有指明类的泛型，则认为此泛型类型为Object类型

38.         //如果定义了类是带泛型的，建议在实例化时要指明类的泛型。

39.         user.setInfo(new String("ylaihui"));

40.         System.out.println(user.getInfo());  // ylaihui

42.         // 建议按以下方式使用泛型类

43.         User<String> su = new User<>();

44.         su.setInfo("aaa");

45.         System.out.println(su.getInfo()); // aaa

47.     }

48. }

4. 继承泛型类

4.1 继承时指定泛型的类型

子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型。子类不再是一个泛型类

1. //GenericClassTest.java

2. package com.ylaihui.generic;

4. class Book<T>{

5.     int id;

6.     String name;

7.     T extend;

9.     public T getExtend() {

10.         return extend;

11.     }

13.     public void setExtend(T extend) {

14.         this.extend = extend;

15.     }

16. }

18. class ITBook extends Book<String>{

19.     public ITBook() {

20.     }

21. }

23. public class GenericClassTest {

24.     public static void main(String[] args) {

25.         ITBook itBook = new ITBook();

26.         itBook.setExtend("This is ylaihui book!");

27.         String extend = itBook.getExtend();

28.         System.out.println(extend);

29.     }

30. }

4.2 继承泛型类时不指定类的泛型

子类实例化时才指定泛型的类型，那么子类、父类都能识别到T

1. //GenericClassTest1.java

2. package com.ylaihui.generic;

4. class Phone<T>{

5.     String name;

6.     double price;

7.     T extend;

9.     public T getExtend() {

10.         return extend;

11.     }

13.     public void setExtend(T extend) {

14.         this.extend = extend;

15.     }

17.     public Phone() {

18.     }

19. }

21. class LenovePhone<T> extends Phone<T>{

22.     T extend1;

24.     public T getExtend1() {

25.         return extend1;

26.     }

28.     public void setExtend1(T extend1) {

29.         this.extend1 = extend1;

30.     }

31. }

33. public class GenericClassTest1 {

34.     public static void main(String[] args) {

35.         LenovePhone<String> lp = new LenovePhone<>();

36.         lp.setExtend("ylaihui");

37.         lp.setExtend1("ylaihui-Phone");

38.         System.out.println(lp.getExtend());  // ylaihui

39.         System.out.println(lp.getExtend1()); // ylaihui-Phone

40.     }

41. }

5. 泛型类、泛型接口的补充说明

1. 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：<E1,E2,E3>  ，比如Map接口

2. 泛型类的构造器如下： public GenericClass(){}。而下面是错误的： public GenericClass<E>(){}

3. 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。

4. 泛型不同的引用不能相互赋值。

尽管在编译时ArrayList<String>和ArrayList<Integer>是两种类型，但是，在运行时只有一个ArrayList被加载到JVM中。

5. 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。

经验： 泛型要使用一路都用。要不用，一路都不要用。一般建议使用，更为严格。

6. 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。

7. jdk1.7，泛型的简化操作： ArrayList<Fruit> flist = new ArrayList<>();  类型推断

8. 泛型的指定中不能使用基本数据类型，可以使用包装类替换。

9. 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。（泛型类型是在实例化对象时指定的，静态方法早于对象的创建，静态方法是属于类的）

10. 异常类不能是泛型的，catch( T t)语句中也不能使用泛型类型

11. 不能使用new E[]。但是可以： E[] elements = (E[])new Object[capacity];  elements 中只能放E类型对象或者E子类类型的对象。

参考： ArrayList源码中声明： Object[] elementData， 而非泛型参数类型数组。

12.父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：

 子类不保留父类的泛型：按需实现

 没有类型 擦除

 具体类型

 子类保留父类的泛型：泛型子类

 全部保留

 部分保留

结论：子类必须是“富二代”，子类是更具体，类型可更加丰富，子类除了指定或保留父类的泛型，还可以增加自己的泛型

1. class Father<T1, T2> {

2. }

3. // 子类不保留父类的泛型

4. // 1)没有类型 擦除

5. class Son1 extends Father {// 等价于class Son extends Father<Object,Object>{

6. }

7. // 2)具体类型

8. class Son2 extends Father<Integer, String> {

9. }

10. // 子类保留父类的泛型

11. // 1)全部保留

12. class Son3<T1, T2> extends Father<T1, T2> {

13. }

14. // 2)部分保留

15. class Son4<T2> extends Father<Integer, T2> {

16. }

17. class Father<T1, T2> {

18. }

19. // 子类不保留父类的泛型

20. // 1)没有类型 擦除

21. class Son<A, B> extends Father{//等价于class Son extends Father<Object,Object>{

22. }

23. // 2)具体类型

24. class Son2<A, B> extends Father<Integer, String> {

25. }

26. // 子类保留父类的泛型

27. // 1)全部保留

28. class Son3<T1, T2, A, B> extends Father<T1, T2> {

29. }

30. // 2)部分保留

31. class Son4<T2, A, B> extends Father<Integer, T2> {

32. }