【原】Java学习笔记027 - 泛型

 1 package cn.temptation.test;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 
 6 public class Sample01 {
 7     public static void main(String[] args) {
 8         ArrayList arrayList = new ArrayList();
 9         
10         arrayList.add("中国");
11         arrayList.add("美国");
12         // 下句会导致执行异常：java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
13         arrayList.add(250);
14         
15         Iterator iterator = arrayList.iterator();
16         
17         while (iterator.hasNext()) {
18             // 因为在向ArrayList对象中添加元素时，add方法的参数类型为Object类型，换句话说，在添加元素时没有做类型检查
19             // 在遍历时，强行要求取出的是某一种数据类型
20             String item = (String) iterator.next();
21             // 上句改为下句，执行时不会有异常产生
22 //            Object item = iterator.next();
23             
24             System.out.println(item);
25         }
26         
27         // 回忆一下，前面使用另一种容器-----数组时，没有出现过取出数据时数据类型不匹配的错误，为何？
28         // 这是因为数组在创建时，就已经规定好了其中的元素是什么数据类型
29         // 数组的这种特点属于"丑话讲在前"，即在编译阶段就提示语法错误的写法具有较好的前瞻性
30 //        int[] arrInt = { 1, 2, 3, "abc" };
31 //        String[] arrString = { "abc", "admin", 123, "test" };
32         
33         // 我们希望在集合的使用中，也有数组的这种优点，即在编译阶段就提示出语法错误的功能
34         // 换句话说，就是在编译阶段就能强制确定集合中的元素的数据类型
35         
36         // Java中引入了       泛型（Generic），从JDK 1.5之后引入的，大家维护早期项目时无法使用泛型的
37     }
38 }

 1 package cn.temptation.test;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 
 6 public class Sample02 {
 7     public static void main(String[] args) {
 8         /*
 9          * 泛型（Generic）
10          * 
11          * 定义：把类型确定的工作推迟到创建对象或方法调用时才做的方式
12          * 
13          * 格式：<数据类型>
14          * 
15          * 注意：泛型中的数据类型只能是引用数据类型，参数化类型（或者称为不明确具体的类型），也就是把数据类型作为参数一样进行传递
16          * 
17          * 优点：
18          * 1、把执行时才能发现的问题提前到编译时发现并处理
19          * 2、避免强制类型转换
20          * 3、让程序中不再到处都出现警告
21          * 
22          * 理解：
23          * 泛型，开始会觉得泛型的"泛"是否指的是有宽泛、广泛的意思，使用后发现使用了泛型，其实对数据类型带来强制性，也就是"泛型不泛"
24          * 
25          */
26         // 在JDK 1.7之前，创建泛型对象时，如下写法：
27 //        ArrayList arrayList = new ArrayList();
28         // 在JDK 1.7之后，创建泛型对象时，简化为如下写法：
29         ArrayList arrayList = new ArrayList<>();
30         
31         arrayList.add("中国");
32         arrayList.add("美国");
33         // 创建了泛型的ArrayList对象后，因为指明了该集合对象中的元素类型为String类型，再向其中放入其他数据类型的元素时，就提示出错了
34         // 【在编译阶段暴露问题    远远好于     在执行阶段暴露问题】
35         // 语法错误：The method add(int, String) in the type ArrayList is not applicable for the arguments (int)
36 //        arrayList.add(250);
37         
38         Iterator iterator = arrayList.iterator();
39         
40         while (iterator.hasNext()) {
41             String item = iterator.next();
42             System.out.println(item);
43         }
44     }
45 }

 1 package cn.temptation.test;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 
 6 public class Sample03 {
 7     public static void main(String[] args) {
 8         /*
 9          * 泛型可以用在哪些地方？
10          * 1、泛型用在类上，称为泛型类
11          * 2、泛型用在接口上，称为泛型接口
12          * 3、泛型用在方法上，称为泛型方法
13          */
14         
15         ArrayList arrayList = new ArrayList<>();
16         
17         arrayList.add("China");
18         arrayList.add("USA");
19         
20         Iterator iterator = arrayList.iterator();
21         
22         while (iterator.hasNext()) {
23             String item = (String) iterator.next();
24             System.out.println(item);
25         }
26     }
27 }

 1 package cn.temptation.test;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 
 6 public class Sample04 {
 7     public static void main(String[] args) {
 8         // 需求：使用泛型ArrayList和Iterator存放并遍历三个学生对象
 9         ArrayList arrayList = new ArrayList<>();
10         
11         arrayList.add(new Student("张三", 20));
12         arrayList.add(new Student("李四", 22));
13         arrayList.add(new Student("王五", 18));
14         
15         Iterator iterator = arrayList.iterator();
16         
17         while (iterator.hasNext()) {
18             Student item = (Student) iterator.next();
19             System.out.println(item);
20         }
21     }
22 }

 1 package cn.temptation.test;
 2 
 3 public class Sample05 {
 4     public static void main(String[] args) {
 5         /*
 6          * 泛型没有出现时，使用Object类型作为引用数据类型转换的桥梁
 7          */
 8         ObjectTool objectTool = new ObjectTool();
 9         
10         objectTool.setObj(new Student("张三", 20));
11         
12         Object obj = objectTool.getObj();
13         System.out.println(obj);
14         
15         // 对Object工具类返回的对象使用具体类型，就必须使用强制类型转换（向下转型）
16         Student student = (Student) objectTool.getObj();
17         System.out.println(student);
18         
19         // 因为向下转型使用强制类型转换，会有风险
20         // 为了能无异常的进行向下转型，必须要清楚的知道向上转型时元素的数据类型
21         // 执行产生异常：java.lang.ClassCastException: cn.temptation.Student cannot be cast to java.lang.String
22         String str = (String) objectTool.getObj();
23         System.out.println(str);
24     }
25 }

 1 package cn.temptation.test;
 2 
 3 /**
 4  * 对象工具类
 5  */
 6 public class ObjectTool {
 7     // 成员变量
 8     private Object obj;
 9 
10     // 成员方法
11     public Object getObj() {
12         return obj;
13     }
14 
15     public void setObj(Object obj) {
16         this.obj = obj;
17     }
18 }

 1 package cn.temptation.test;
 2 
 3 public class Sample06 {
 4     public static void main(String[] args) {
 5         ObjectToolEx objectToolEx = new ObjectToolEx<>();
 6         
 7         objectToolEx.setObj(new Student("张三", 20));
 8         // 语法错误：The method setObj(Student) in the type ObjectToolEx is not applicable for the arguments (int)
 9 //        objectToolEx.setObj(123);
10         // 语法错误：The method setObj(Student) in the type ObjectToolEx is not applicable for the arguments (String)
11 //        objectToolEx.setObj("abc");
12         // 语法错误：The method setObj(Student) in the type ObjectToolEx is not applicable for the arguments (Integer)
13 //        objectToolEx.setObj(new Integer(456));
14         
15         // 理解：泛型 -----> 范型（规范类型），"泛型有范"
16     }
17 }

 1 package cn.temptation.test;
 2 
 3 /**
 4  * 对象工具类（泛型版）：使用泛型对ObjectTool工具类进行升级
 5  * 
 6  * 思路：
 7  * 原来使用Object类作为方法形参的类型以及成员变量的类型，都是出于通用性的考虑（即越抽象越好）
 8  * 现在在类的声明时，不急于确定传入进来的对象到底是什么类型，而是使用占位符把位置先占住，在使用时，根据传入进来的数据类型进行相应的设置
 9  * 优点在于使用时明确到底用什么类型，避免了强制类型转换
10  * 使用泛型的占位符，先不需要知道数据类型是什么，推迟到类的实例化（具体使用时）再去替换为对应的数据类型
11  */
12 public class ObjectToolEx {
13     // 成员变量
14     private T obj;
15     private T resultT;
16     // 语法错误：E cannot be resolved to a type
17 //    private E resultE;
18     
19     // 成员方法
20     public T getObj() {
21         return obj;
22     }
23 
24     public void setObj(T obj) {
25         this.obj = obj;
26     }
27     
28     // 泛型方法1、参数类型与类的类型一致
29     public void show(T param) {
30         System.out.println(param);
31     }
32     
33     public T showEx(T param) {
34         return resultT;
35     }
36     
37     // 泛型方法2、参数类型与类的类型不一致
38     public  void method(E param) {
39         System.out.println(param);
40     }
41     
42     // 泛型方法的返回值类型和其所在泛型类不一致时，只能返回null值，返回其他类型语法错误
43     public  E methodEx(E param) {
44         // 语法错误：resultE cannot be resolved to a variable
45 //        return resultE;
46         
47         // 下面写法语法OK，但是返回的是null值
48         return null;
49     }
50 }

 1 package cn.temptation.test;
 2 
 3 public class Sample07 {
 4     public static void main(String[] args) {
 5         // 泛型类的使用，可以传递的数据类型只能是引用数据类型
 6 //        ObjectToolEx objectToolEx = new ObjectToolEx<>();
 7 //        objectToolEx.setObj("java");
 8 //        System.out.println(objectToolEx.getObj());
 9         
10         // 语法错误：Syntax error, insert "Dimensions" to complete ReferenceType
11 //        ObjectToolEx objectToolEx = new ObjectToolEx<>();
12     }
13 }

 1 package cn.temptation.test;
 2 
 3 public class Sample08 {
 4     public static void main(String[] args) {
 5         // 泛型方法的定义，参数可以和其所在的泛型类的类型相同，也可以不相同
 6         // 参数不相同的使用时，根据传入的数据类型进行相应的使用
 7         
 8         ObjectToolEx objectToolEx = new ObjectToolEx<>();
 9         
10         objectToolEx.show("admin");                            // admin
11         System.out.println(objectToolEx.showEx("test"));    // null
12         
13         objectToolEx.method(123);                            // 123
14         System.out.println(objectToolEx.methodEx(true));    // null
15     }
16 }

 1 package cn.temptation.test;
 2 
 3 public class Sample09 {
 4     public static void main(String[] args) {
 5         // 1、创建泛型接口时，已经明确泛型接口使用的数据类型是什么类型
 6         Foo foo1 = new FooImpl();
 7         foo1.show("java");
 8         
 9         // 2、创建接口的实现类对象时，才传入泛型接口使用的数据类型是什么类型
10         Foo foo2 = new FooImplEx<>();
11         foo2.show(123);
12     }
13 }

1 package cn.temptation.test;
2 
3 /**
4  * 泛型接口
5  * @param 
6  */
7 public interface Foo {
8     public abstract void    show(T param);
9 }

 1 package cn.temptation.test;
 2 
 3 /**
 4  * 制作泛型接口的实现类时，已经知道泛型接口使用的是什么数据类型
 5  */
 6 public class FooImpl implements Foo {
 7     // 既然已经知道泛型接口使用的是什么数据类型，那么重写的成员方法也就明确使用什么数据类型
 8     @Override
 9     public void show(String param) {
10         System.out.println(param);
11     }
12 }

 1 package cn.temptation.test;
 2 
 3 /**
 4  * 制作泛型接口的实现类时，还不知道泛型接口使用的是什么数据类型
 5  * 实现类需要和泛型接口使用相同数据类型的占位符
 6  * 
 7  * @param 
 8  */
 9 public class FooImplEx implements Foo {
10     // 既然还不知道泛型接口使用的是什么数据类型，那么重写的成员方法也就不能明确使用什么数据类型，那么还是使用占位符先占住位置
11     @Override
12     public void show(T param) {
13         System.out.println(param);
14     }
15 }

 1 package cn.temptation.test;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collection;
 5 
 6 public class Sample10 {
 7     public static void main(String[] args) {
 8         /*
 9          * 泛型的通配符
10          * ?            ：任意类型
11          * ?  extends T    ：向下限定，指的是  ? 对应的类型必须是  T 对应的类型的子类或自身
12          * ?  super T    ：向上限定，指的是  ? 对应的类型必须是  T 对应的类型的父类或自身
13          */
14         
15         Collection