泛型的简单概述
泛型是JDK1.5版本以后出现的新特性。它用于解决安全问题，是一个类型安全机制。
泛型的由来
概念说完之后，我们来看看Java语言是如何引入泛型的。在JDK1.4版本之前，容器什么类型的对象都可以存储，但是在取出时，需要用到对象的特有内容时，这时需要做向下转型。比如下面的程序：
public class MyGenericDemo {
public static void main(String[] args) {
List list = new ArrayList();
list.add("abc");
list.add(4); // list.add(Integer.valueOf(4)); 由于集合没有做任何限定，任何类型都可以存放在其中
for (Iterator it = list.iterator(); it.hasNext();) {
String str = (String) it.next();
System.out.println(str.length());
}
}
}
程序在运行的时候发生了异常：java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String，其主要原因是对象的类型不一致。
为了避免这个问题，所以程序员们只能主观上控制，往集合中存储的对象类型保持一致。JDK1.5以后解决了该问题，即在定义集合时，就直接明确集合中存储元素的具体类型，这样，编译器在编译时，就可以对集合中存储的对象类型进行检查，一旦发现类型不匹配，就编译失败。这个技术就是泛型技术。
泛型的格式
泛型的格式是通过<>来定义要操作的引用数据类型。
泛型的好处
泛型的好处：
- 将运行时期出现的问题(例如ClassCastException异常)，转移到了编译时期，方便于程序员解决问题，让运行时期问题减少，安全；
- 避免了向下转型的麻烦；
- 优化了程序设计，解决了黄色警告线。
总结：泛型就是应用在编译时期的一项安全机制。
泛型的擦除
泛型的擦除用一句话来说就是：编译器通过泛型对元素类型进行检查，只要检查通过，就会生成class文件，但在class文件中，就将泛型标识去掉了。
泛型的表现
泛型技术在集合框架中应用的范围很大。那么什么时候需要写泛型呢？只要看到类或接口在描述的时候右边有定义<>，就需要泛型了。其实是容器在不明确操作元素的类型的情况下，对外提供了一个参数<>，使用容器时，只要将具体的类型实参传递给该参数即可。说白了，泛型就是传递类型参数。
使用泛型技术存储整数
例，创建一个List集合，用于存储整数，使用泛型技术。
package cn.liayun.generic.demo;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class GenericDemo2 {
public static void main(String[] args) {
//创建一个List集合，存储整数。List接口和ArrayList类
List<Integer> list = new ArrayList<Integer>();
list.add(5);
list.add(6);
for (Iterator<Integer> it = list.iterator(); it.hasNext();) {
Integer integer = it.next();
System.out.println(integer);
}
}
}
使用泛型技术存储自定义对象
例，将Person对象存储到TreeSet集合中，同姓名同年龄的视为同一个人，不存；按照学生的姓名进行升序排序，而且当姓名相同时，需要按照学生的年龄进行升序排序。
分析：此题主旨就是复习一下TreeSet集合和Comparator接口，我们定义一个比较器实现Comparator接口，覆盖compare方法，将Comparator接口的实现类作为参数传递给TreeSet集合的构造函数。
先描述Person类，由于Person类的对象有可能存放到HashSet集合中，所以我们最好还是覆盖hashCode()和equals()方法。而且我们还让Person类实现了Comparable接口，强制让Person类具备比较性。
package cn.liayun.domain;
public class Person implements Comparable<Person> {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
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;
}
@Override
public int hashCode() {
final int NUMBER = 38;
return this.name.hashCode() + age * NUMBER;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof Person)) {
throw new ClassCastException("类型错误");
}
Person per = (Person)obj;
return this.name.equals(per.name) && this.age == per.age;
}
@Override
public int compareTo(Person o) {
int temp = this.age - o.age;
return temp == 0 ? this.name.compareTo(o.name) : temp;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
接着自定义一个比较器。
package cn.liayun.comparator;
import java.util.Comparator;
import cn.liayun.domain.Person;
public class ComparatorByName implements Comparator<Person> {
@Override
public int compare(Person o1, Person o2) {
int temp = o1.getName().compareTo(o2.getName());
return temp == 0 ? o1.getAge() - o2.getAge() : temp;
}
}
最后编写一个测试类，进行测试。
package cn.liayun.generic.demo;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
import cn.liayun.comparator.ComparatorByName;
import cn.liayun.domain.Person;
public class GenericDemo3 {
public static void main(String[] args) {
Set<Person> set = new TreeSet<Person>(new ComparatorByName());
// set = new HashSet<Person>();
set.add(new Person("abcd", 20));
set.add(new Person("abcd", 20));
set.add(new Person("aa", 26));
set.add(new Person("nba", 22));
set.add(new Person("nba", 22));
set.add(new Person("cba", 24));
for (Person person : set) {
System.out.println(person);
}
}
}
自定义泛型类
现在有两个类，分别为Student和Worker，如下：
-
Student.java
package cn.liayun.domain; public class Student extends Person { public Student() { super(); } public Student(String name, int age) { super(name, age); } @Override public String toString() { return "Student [name = " + getName() + ", age = " + getAge() + "]"; } } -
Worker.java
package cn.liayun.domain; public class Worker extends Person { public Worker() { super(); } public Worker(String name, int age) { super(name, age); } @Override public String toString() { return "Worker [name=" + getName() + ", age=" + getAge() + "]"; } }
现在我们需要创建一个用于操作Student对象的工具类，对对象进行设置和获取。其实想都不会想，我们就会这么做：
class Tool {
private Student stu;
public Student getStu() {
return stu;
}
public void setStu(Student stu) {
this.stu = stu;
}
}
可是发现太有局限性了，这时我们就要想可不可以定义一个可以操作所有对象的工具呢？答案是可以的，当要操作的对象类型不确定的时候，为了扩展，可以使用Object类型来完成，但是这种方式有一些小弊端，会出现向下转型，向下转型容易在运行时期发生java.lang.ClassCastException。下面就是JDK1.4版本时(此时泛型技术还没出现)的代码：
//JDK1.4
class Tool {
private Object obj;
public Object getObj() {
return obj;
}
public void setObj(Object obj) {
this.obj = obj;
}
}
JDK1.5以后，新的解决方案出现了。当类型不确定时，可以对外提供参数，由使用者通过传递参数的形式完成类型的确定。这样工具类的代码就可这样写为：
//在类定义时就明确参数，由使用该类的调用者来传递具体的类型。
class Util<W> {//泛型类
private W obj;
public W getObj() {
return obj;
}
public void setObj(W obj) {
this.obj = obj;
}
}
以上就是一个自定义的泛型类。
小结
什么时候定义泛型类呢？当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展，现在定义泛型来完成扩展。
泛型方法
泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了，为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。特殊之处：静态方法不可以访问类上定义的泛型。如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。
package cn.liayun.generic.demo;
public class GenericDemo {
public static void main(String[] args) {
Demo<String> d = new Demo<String>();
d.show("abc");
d.print("abc");
d.print(6);
}
}
class Demo<W> {
public /*static*/ void show(W w) {//静态方法是无法访问类上定义的泛型的。如果静态方法需要定义泛型，泛型只能定义在方法上。
System.out.println("show: " + w);
}
public static <A> void staticShow(A a) {
System.out.println("static show: " + a);
}
public <Q> void print(Q w) {//泛型方法
System.out.println("print: " + w);
}
}
泛型接口
泛型可定义在接口上。如：
interface Inter<T> {//泛型接口
public void show(T t);
}
泛型接口有两种实现方式，其中一种实现方式为：
package cn.liayun.generic.demo;
public class GenericDemo {
public static void main(String[] args) {
InterImpl in = new InterImpl();
in.show("hello generic type");
}
}
interface Inter<T> {//泛型接口
public void show(T t);
}
class InterImpl implements Inter<String> {
@Override
public void show(String t) {
System.out.println(t);
}
}
第二种实现方式为：
package cn.liayun.generic.demo;
public class GenericDemo6 {
public static void main(String[] args) {
SubDemo d = new SubDemo();
d.show("abc");
}
}
interface Inter<T> {//泛型接口
public void show(T t);
}
class InterImpl<W> implements Inter<W> {
@Override
public void show(W t) {
System.out.println("show: " + t);
}
}
class SubDemo extends InterImpl<String> {
}
泛型通配符
泛型是在限定数据类型，当在集合或者其他地方使用到泛型后，那么这时一旦明确泛型的数据类型，那么在使用的时候只能给其传递与数据类型相匹配的类型，否则就会报错。
上面调用方法语句属于语法错误，因为泛型限定不一致。方法要的是Collection<Object>类型，但传入的是List<Student>或者Set<String>，二者类型不匹配。
上述定义的printCollection方法中，由于定义的是打印集合的功能，应该是可以打印任意集合中的元素的。但定义方法时，根本无法确定具体集合中的元素类型是什么。为了解决这个”无法确定具体集合中的元素类型”问题，Java中为我们提供了泛型的通配符<?>。对上面的方法，进行修改后，实现了可迭代任意元素类型集合的方法。
private static void printCollection(Collection<?> coll) {//在不明确具体类型的情况下，可以使用通配符来表示。
for (Iterator<?> it = coll.iterator(); it.hasNext();) {
Object obj = it.next();
System.out.println(obj);
}
}
总结一下：当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。
泛型的上限
泛型的限定有两种表现形式，上限和下限。其中上限的格式为：
? extends E：可以接收E类型或者E类型的子类型，泛型的上限
现在我们来演示泛型的上限在API中的体现，以TreeSet的构造函数——TreeSet(Collection<? extends E> c)为例来详细讲解泛型的上限。
TreeSet集合中有一个这样的构造方法：
public TreeSet(Collection<? extends E> c) { }
根据该构造方法可以构造一个带有内容的TreeSet集合，该例中所涉及到的3个类——Person、Student、Worker前文都有描述，继承体系为：
package cn.liayun.generic.demo;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.TreeSet;
import cn.liayun.domain.Person;
import cn.liayun.domain.Student;
public class GenericDemo9 {
public static void main(String[] args) {
/*
* 演示泛型限定在api中的体现。
* TreeSet的构造函数。
* TreeSet(Collection<? extends E> coll);
*
* 什么时候会用到上限呢？
* 一般往集合中存储元素时，如果集合中定义了E类型，通常情况下应该存储E类型的对象。
* 对于E的子类型的对象，E类型也可以接受，所以这时可以将泛型从E改为? extends E。
*/
Collection<Student> coll = new ArrayList<Student>();
coll.add(new Student("abc1", 21));
coll.add(new Student("abc2", 22));
coll.add(new Student("abc3", 23));
coll.add(new Student("abc4", 24));
TreeSet<Person> ts = new TreeSet<Person>(coll);
ts.add(new Person("abc8", 21));
for (Iterator<Person> it = ts.iterator(); it.hasNext();) {
Person person = it.next();
System.out.println(person.getName());
}
}
}
class MyTreeSet<E> {
MyTreeSet() {
}
MyTreeSet(Collection<? extends E> c) {
}
}
小结
什么时候会用到泛型上限呢？一般往集合中存储元素时，如果集合定义了E类型，通常情况下应该存储E类型的对象。对E的子类型的对象也可以接收，所以这时可以将泛型从E改为? extends E。
泛型的下限
下限的格式为：
? super E：可以接收E类型或者E的父类型，泛型的下限
现在我们来演示泛型的下限在API中的体现，以TreeSet的构造函数——TreeSet(Comparator<? super E> comparator)为例来详细讲解泛型的下限。
TreeSet集合中有一个这样的构造方法：
publicTreeSet(Comparator<? super E> comparator) { }
该例中所涉及到的3个类——Person、Student、Worker前文都有描述，继承体系同上。
package cn.liayun.generic.demo;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
import cn.liayun.domain.Person;
import cn.liayun.domain.Student;
import cn.liayun.domain.Worker;
public class GenericDemo10 {
public static void main(String[] args) {
/*
* 演示泛型限定在api中的体现。
* TreeSet的构造函数。
* TreeSet(Comparator<? super E> comparator);
*
* 什么时候会用到下限呢？
* 当从容器中取出元素进行操作时，可以用E类型接收，也可以用E的父类型接收。
*/
//创建一个比较器。
Comparator<Person> comp = new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
int temp = o1.getAge() - o2.getAge();
return temp == 0 ? o1.getName().compareTo(o2.getName()) : temp;
}
};
TreeSet<Student> ts = new TreeSet<Student>(comp);
ts.add(new Student("abc1", 21));
ts.add(new Student("abc2", 28));
ts.add(new Student("abc3", 23));
ts.add(new Student("abc4", 25));
TreeSet<Worker> ts1 = new TreeSet<Worker>(comp);
ts1.add(new Worker("abc11", 21));
ts1.add(new Worker("abc22", 27));
ts1.add(new Worker("abc33", 22));
ts1.add(new Worker("abc44", 29));
for (Iterator<Student> it = ts.iterator(); it.hasNext();) {
Student student = it.next();
System.out.println(student);
}
}
}
class YouTreeSet<E> {
YouTreeSet(Comparator<? super E> comparator) {
}
}
小结
什么时候会用到泛型下限呢？当从容器中取出元素操作时，可以用E类型接收，也可以用E的父类型接收。