Java泛型全解析接口类封装类型
Posted 知青先生
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java泛型全解析接口类封装类型相关的知识，希望对你有一定的参考价值。
泛型
泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。Generic有“类的，属性的”之意，在Java中代表泛型。泛型作为一种安全机制而产生。
为何需要泛型？
我们知道集合(Collection、Map之类的容器)是用来存储任意对象(Object)的一系列“容器类或者接口”，注意这里的“任意对象”,就是指我们可以在这些类或接口中存放任意类型的对象，但这些对象在存储之前都需要统一向上转型为Object类型(因为Object类是所以类的的父类)，比如类ArrayList就属于“集合类”，我们可以用这个类来存储任意对象：
package bean;
import java.util.ArrayList;
public class ArrayListDemo
public static void main(String[] args)
//首先我们创建一个ArrayList对象
ArrayList al = new ArrayList();
//往"容器"添加元素：我们添加了字符串"哈哈",数字2,boolean类型true，最后我们甚至添加了自己。
al.add("哈哈");
al.add(2);
al.add(true);
al.addAll(al);
//由于ArrayList类覆盖了toString()，这里我们可以直接打印查看效果：
System.out.println(al);
最后打印出来的字符串是：[哈哈, 2, true, 哈哈, 2, true]
值得注意的是：这里的2不是int而是Integer，因为ArrayList只能存对象，而“添加它自己”addAll(al)的实质是将al中的所有元素再存入al中，正如打印效果显示的一样，我们成功添加了类型不一样的对象：有String，有Integer、还有Boolean。当然，你可以添加任意你想要添加的对象。因为这些对象在存入“容器”al中时会全部转型为Object类型，有没有觉得这样的“容器”用起来会很爽，什么东西都能往里放。但是，便捷往往会付出相应代价。
我们将各种类型的元素存入“容器”中当然不是让它睡上一觉，我们需要将存储的元素取出使用。对于这些“容器”，我们一般使用迭代器Iterator来获取每一个元素。(这里不进行迭代器使用说明，只需理解迭代器是取出"容器"中元素的工具就行).
假设现在我们需要对我们上面创建的“容器”al中的元素进行操作：打印容器中字符串的长度，即“哈哈”的长度。
package bean;
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListDemo
public static void main(String[] args)
//首先我们创建一个ArrayList对象,并添加对象
ArrayList al = new ArrayList();
al.add("哈哈");
al.add(2);
al.add(true);
//使用迭代器Iterator进行遍历，并打印容器中字符串的长度：
//注：next()方法是按照容器的存储顺序，逐一取出第一个到最后一个对象。
Iterator i = al.iterator();
while(i.hasNext())
String s = (String) i.next();
System.out.println(s.length());
我们来进行代码分析：while循环中，先用i.next()方法取出第一个元素"哈哈"，然后装换为String类型(因为存进去的时候是Object类型，使用的使用要向下转型)，所以接下来打印了“哈哈”的长度=2。接着循环：迭代器取出第二个元素：2，但这是Integer类型不能强制装换为String类型，所以抛出异常：ClassCastException：类型转换异常。
这就是“能存万物”所带来的代价：我们在使用“容器”存储对象并调用时就换存在“类型转换异常”的安全隐患，但这需要在运行后才能得知，编译时无法发现。所以我们该如何解决这个问题呢？我们发现问题在于“类型转换异常”，所以我们只要保证“容器”中存储的是同一类型的元素就不会出现这个异常了。类似数组的定义一样：如 int[] 就表示专门用来存储int类型数据的数组，String[] 就是用来存储String类型数据的数组。我们只要将“容器”标上相应类型的标签就可以了。看到这里，你应该已经理解了泛型的由来，这就是泛型的设计：引入类型参数的概念，即对对象类型进行申明。
3、泛型的定义格式
格式为：类名<类型名>，如：
package bean;
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListDemo
public static void main(String[] args)
//首先我们创建一个ArrayList对象,并申明泛型类型为String类型：只能存储String类型的对象
ArrayList<String> al = new ArrayList<String>();
al.add("哈哈");
al.add("asdafa");
al.add("tobeyourself");
//使用迭代器Iterator进行遍历，并打印容器中字符串的长度：这里迭代器也使用了泛型
Iterator<String> i = al.iterator();
while(i.hasNext())
String s = (String) i.next();
System.out.println(s+"的长度为="+s.length());
泛型的好处
除了解决上面的安全隐患即抛出异常问题，泛型的类或接口在取出对象时将不需要再进行向下类型转换，因为存储的时候就是该类型 。
另外，泛型的使用让安全问题在编译时就报错而不是运行后抛出异常，这样便于程序员及时准确地发现问题。
什么时候使用泛型？
一般类或接口在api文档中的定义中带有<E>标识的，在使用的时候都需要使用泛型机制。如ArrayList<E>、Iterator<E>。
泛型的擦除
泛型是运用在编译时期的技术：编译时编译器会按照<类型名>的类型对容器中的元素进行检查，检查不匹配，就编译失败。如果全部检查成功，则编译通过，但，编译通过后产生的.class文件中并没有<类型名>这个标识，即类文件中没有泛型，这就是泛型的擦除。
一句话总结就是：在.java文件运用泛型技术时，编译器在文件编译通过后自动擦除泛型标识。
由于泛型的擦除，类文件中没有泛型机制，同时也没有使用向下类型转换，那么为何运行时无异常？
泛型的补偿
编译器在擦除泛型后，会自动将类型转换为原定义的"泛型"，这样就不必再做向下类型转换了。
泛型的擦除和补偿 这两个机制都是编译器内部自动完成的，了解其原理即可。
泛型的应用
7.1【泛型类】
所谓的泛型类就是运用到泛型技术的类，如上面讲到的ArrayList，Iterator等都是java中的泛型类，这些类都是Java已经定义好的泛型类，直接使用就可以了。但有时候我们会遇到这样的问题：
假设我们现在有两个自定义类：Worker类和Student类，现在我们需要一个工具类Tool来获取Worker对象和Student对象，并能对对象进行操作。
分析：
我们可能会想到将Worker和Student类作为Tool类的成员变量，以此来实现对这两个类的操作。但这样有一个问题，就是如果这不是两个类而是很多类，甚至说无数个类，即Tool类可以操作任意类，这种通过添加成员变量来实现调用对象的方法显然不可行。注意这个“添加任意对象”，这不就是上面说的ArrrayList这些类所具有的特点吗？泛型类就是为了解决“添加任意对象”而产生的，这里提到的ArrayList属于已定义泛型类(Java中自带的)，这里我们要用到Tool类来“存储任意对象”，所以要将Tool类定义为泛型类，这就是根据需求自己设计的自定义泛型类：
首先我们先简单的定义一下:Worker类和Student类：
Worker类：
package bean;
public class Worker
private String name;
private int age;
Worker()
Worker(String name,int age)
this.name = name;
this.age = age;
public String getName()
return name;
public void setName(String name)
this.name = name;
public int getAge()
return age;
public void setAge(int age)
this.age = age;
Student类：
1 package bean;
2
3 public class Student
4 private String name;
5 private String sex;
6 Student()
7
8
9 Student(String name,String sex)
10 this.name = name;
11 this.sex = sex;
12
13 public String getName()
14 return name;
15
16 public void setName(String name)
17 this.name = name;
18
19 public String getSex()
20 return sex;
21
22 public void setSex(String sex)
23 this.sex = sex;
24
25
26
现在我们需要将Tool类定义为泛型类：(注意格式)
1 package bean;
2
3 public class Tool<E>
4 private E e;
5
6 public Tool(E e1)
7 this.e = e1;
8
9
10 public E getE()
11 return e;
12
13 public void setE(E e)
14 this.e = e;
15
16
17
这里我们写的很简单，但已经满足需求了，重点在于泛型类的写法：Tool，这里的E字母可以写你自己喜欢的代码，这也就是类型参数的应用，E相当于一个类型参数，代表了Tool可以传入任意对象，下面我们具体使用来看看效果：
1 package bean;
2
3 class Tooltest
4 public static void main(String[] args)
5 //假设有两个对象：一个学生，一个工人
6 Student t1 = new Student("张三","男");
7 Worker w1 = new Worker("李四",20);
8
9 //现在我们使用Tool类来调用t1和w1
10 Tool<Student> ts = new Tool<Student>(t1);
11 Tool<Worker> tw = new Tool<Worker>(w1);
12
13 //打印查看效果
14 System.out.println("使用ts调用t1中的数据："+ts.getE().getName()+":"+ts.getE().getSex());
15 System.out.println("使用tw调用w1中的数据："+tw.getE().getName()+":"+tw.getE().getAge());
16
17
打印结果为：
使用ts调用t1中的数据：张三:男
使用tw调用w1中的数据：李四:20
7.2【泛型方法】
泛型方法类似于静态类的设计，一般的方法传入的参数是固定类型的，如public void show(int i)这个方法的参数类型固定为int，但是泛型方法可以传入指定的参数类型。一般泛型定义有两种形式：
1)使用泛型类的参数类型来定义(常用)：
如泛型类Tool<QQ>，它的泛型参数即为QQ。那么泛型方法可以这样写：public void show(QQ qq).
2)使用自定义的参数类型来定义：
如果我们需要自定义参数类型，那么我们把泛型参数放在方法上就可以了(放在返回值类型之前)：public <AA> void show(AA aa)。
注：静态方法不能访问类的泛型，如果需要泛型，我们只能使用方法2)，在方法上使用泛型即可：public static <AA> void show(AA aa)
【泛型接口】
和上面一样的道理，当我们不确定使用对象的类型时，运用泛型就可以解决问题，泛型接口和泛型类的使用是一样一样的。
我们只需要注意，在实现泛型接口时有两种情况：这里假设有泛型接口interf<AA>，它的实现类是Tool。
1)确定实现的泛型接口的参数类型：
假设Tool类需要String类型的参数，那么实现可以直接写：class Tool implements interf<String>即可。
2)不确定实现的泛型接口的参数类型：
这时候我们需要泛型类来实现classTool<BB> implements interf<BB>.
泛型の通配符：？
当我们不确定传入的对象类型时我们就可以使用？来代替。“？”即泛型通配符。
泛型的限定
我们知道使用泛型类时：如果明确参数类型，那么泛型就代表一种类型；如果使用通配符？，那么泛型就代表任意类型。但有时候我们希望指定某些类型(不是一个，也不要所有)能作为参数类型，这应该怎么办呢？
Java中利用泛型的限定解决了这个问题，即泛型的限定。我们只需要按这样的格式书写：
上限：<？ extends E>表示参数类型是E及其所有子类。
下限：<? super E>表示参数类型是E及其所有超类(即父类)。
以上是关于Java泛型全解析接口类封装类型的主要内容，如果未能解决你的问题，请参考以下文章