黑马程序员——Java集合框架（二）之泛型

----------android培训、java培训、java学习型技术博客、期待与您交流！------------

　　　　　　　　　　　　　　泛型

一、泛型概述

　1.什么是泛型？

　　泛型就是指将数据类型参数化，把以前固定的数据类型用一个代表数据类型的参数进行表示，该参数可以接受传入的任意数据类型。可以这样理解，如果把常量数值1当做一种数据类型，那么将常量数值１变成变量a的过程就可以理解为参数化过程，此时ａ既可以接受常量数值１的数据类型，也可以接受常量数值２、３等的数据类型，那么此时变量a就可以理解为泛型。

　　泛型是jdk1.5版本出现的新特性，用于解决安全问题，是一个安全机制。

　2.泛型的好处

　　a）将运行时期出现的问题ClassCastException，转移到了编译时期。方便于程序员解决问题。让运行时期问题减少、安全。

　　b）避免了强制转换的麻烦。如在实现某一个接口时，指定传入接口方法的实参的类型的话，在复写该接口方法时就可以直接使用指定类型，而不需要强制转换。

　3.泛型格式

　　通过<>来定义要操作的引用数据类型。

　　泛型：

　　　格式：<T>

　　　示例：ArrayList<T>，表示该集合存入的元素为T类型，T可以为任意对象类型。

　　泛型实例：泛型实例就是将泛型参数实例化。

　　　格式：<具体数据类型>

　　　示例：ArrayList<String>，表示该集合存入的元素必须为String类型。

　4.通配符

　　通配符也称占位符，表示格式为：<?>

　　示例：ArrayList<？>，表示该集合存入的元素为任意对象类型，？表示占位符，也称通配符。

　5.泛型注意事项

　　1）泛型是提供给javac编译器使用，生成的字节码文件会去掉“类型”信息，使程序运行效率不受影响，对参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。

　　2）由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，如用反射得到集合，再调用add方法即可。

　6.问题思考

　　1）在使用java提供的对象时，什么时候写泛型？

　　　答：泛型通常在集合框架中很常见，只要见到<>就要定义泛型。其实<>就是用来接收类型的。当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

二、泛型类

　1.什么是泛型类

　　当泛型定义在类名上时，该类就叫泛型类。

　2.泛型类的格式

　　泛型类：

　　　class 类名<T> ｛ 类的内容｝

　　　其中，T为泛型参数，类中内容可以存在使用T的方法或成员变量或返回值类型或参数类型等。

　　泛型实例类：是指在类中定义泛型，并且泛型参数已经实例化，即已经确定数据类型。

　　　calss 类名<具体数据类型> { 类的内容 }

　　　例如：class 类名<String> { 类的内容 }，表示将类中String类型提升为Object类型，在类中String对象不能使用其特有方法，且静态方法中不能存在String对象。

　　示例1：定义泛型参数类

class Utils<QQ>
{
	private QQ q;

	public void setObject(QQ q)
	{
		this.q=q;
	}

	public QQ getObject()
	{
		return q;
	}
}

　　示例2：定义泛型实例类

class Person<Character>
{
	private int age;
	private String name;

	public void setName(String name)
	{
		this.name=name;
	}

	public void setAge(int age)
	{
		this.age=age;
	}
}

　3.代码练习

/*
练习1：自定一个泛型类，完成对任意对象的操作。
*/
class  GenericTest1
{
	public static void main(String[] args) 
	{
		Utils<Worker> u=new Utils<Worker>();

		u.setObject(new Worker());
		Worker w=u.getObject();
	}
}

class Worker
{
}

//定义一个泛型类
class Utils<QQ>
{
	private QQ q;

	public void setObject(QQ q)
	{
		this.q=q;
	}

	public QQ getObject()
	{
		return q;
	}
}<strong>
</strong>

三、泛型方法

　1.概述

　　在方法上定义泛型，该方法就称为泛型方法。

　2.格式：

　　修饰符 <T> 返回值类型 函数名称（参数类型1 名称1，...）

　　例如：public <T> void show(T t){ 方法内容 }

　3.示例：

　　在类中定义泛型方法：

class PrintDemo
{
	//定义泛型方法
	public <T> void print(T t)
	{
		System.out.println(t);
	}
}

四、静态泛型方法

　1.概述

　　在静态方法上定义泛型，该静态方法就称为静态泛型方法。

　2.格式：

　　修饰符 static <T> 返回值类型 函数名称（参数类型1 名称1，...）

　　例如：public　static <T> void show(T t){ 方法内容 }

　3.示例：

　　在类中定义静态泛型方法：

class PrintDemo
{
	//定义静态泛型方法
	public static <T> void print(T t)
	{
		System.out.println(t);
	}
}

五、泛型接口

　1.概述

　　在接口上定义泛型，该接口就称为泛型接口。

　2.格式：

　　泛型接口：

　　　interface 接口名<T> { 接口的内容 }

　　泛型实例接口：

　　　interface 接口名<具体数据类型> { 接口的内容 }

　　　示例：interface 接口名<String> { 接口的内容 }，表示将该接口中的String类型提升为Object类型，String对象只能调用Object来中的方法，而不能调用其特有方法。

　3.代码练习：

<span style="font-size:14px;">/*
练习2：定义泛型接口，并利用泛型接口进行操作。
*/

class  GenericTest2
{
	public static void main(String[] args) 
	{
		/*
		InterImp i=new InterImp();
		i.show("hello");
		*/

		InterImp<Integer> i=new InterImp<Integer>();
		i.show(2);
	}
}

//定义一个泛型接口
interface Inter<T>
{
	void show(T t);
}

/*
class InterImp implements Inter<String>
{
	public void show(String s)
	{
		System.out.println("show run:"+s);
	}
}
*/

//定义一个类，实现泛型接口，并成为泛型参数类
class InterImp<T> implements Inter<T>
{
	public void show(T t)
	{
		System.out.println("show run："+t);
	}
}</span>

　　程序运行后的结果如下图：

六、泛型限定

　1.概述

　　泛型限定是指将泛型的参数类型限定范围。

　2.格式

　　1）限定上限：<? extends E>

　　　示例：ArrayList<? extends E>，表示该集合存入的元素只能为E类型或E的子类型。

　　2）限定下限：<? super E>

　　　示例：ArrayList<? super E>，表示该集合存入的元素只能为E类型或E的父类型。

　3.代码练习：

　　练习3：利用泛型上限操作不同对象数据类型的集合。

import java.util.*;
/*
练习3：利用泛型上限操作不同对象数据类型的集合。
*/
class GenericTest3
{
	public static void main(String[] args) 
	{
		ArrayList<Person> al=new ArrayList<Person>();

		al.add(new Person("abc01"));
		al.add(new Person("abc02"));
		al.add(new Person("abc03"));

		ArrayList<Student> all=new ArrayList<Student>();

		all.add(new Student("java01"));
		all.add(new Student("java02"));
		all.add(new Student("java03"));

		printArr(al);
		printArr(all);

	}

	public static void printArr(ArrayList<? extends Person> a)
	{
		Iterator<? extends Person> i=a.iterator();
		while (i.hasNext())
		{		
			System.out.println(i.next().getName());
		}
	}
}

class Person
{
	private String name;

	Person(String name)
	{
		this.name=name;
	}

	public String getName()
	{
		return name;
	}
}

class Student extends Person
{
	Student(String name)
	{
		super(name);
	}
}

　　　程序运行后的结果如下图：

　　　练习4：利用泛型下限操作不同对象类型的集合。

import java.util.*;

class GenericTest4 
{
	public static void main(String[] args) 
	{
		TreeSet<Student> ts=new TreeSet<Student>(new Comp());

		ts.add(new Student("student05"));
		ts.add(new Student("student03"));
		ts.add(new Student("student02"));

		TreeSet<Worker> tss=new TreeSet<Worker>(new Comp());

		tss.add(new Worker("worker04"));
		tss.add(new Worker("worker03"));
		tss.add(new Worker("worker06"));

		for (Iterator i=ts.iterator();i.hasNext() ; )
		{
			Student s=(Student)i.next();
			System.out.println(s.getName());
		}

		for (Iterator i=tss.iterator();i.hasNext() ; )
		{
			Worker w=(Worker)i.next();
			System.out.println(w.getName());
		}
	}
}

//泛型参数指定Person，表示可以接受Person的子类型，即可以接收Worker和Student
class Comp implements Comparator<Person>
{
	public int compare(Person p1,Person p2)
	{
		return p1.getName().compareTo(p2.getName());
	}
}

class Person
{
	private String name;

	Person(String name)
	{
		this.name=name;
	}

	public String getName()
	{
		return name;
	}
}

class Student extends Person
{
	Student(String name)
	{
		super(name);
	}
}

class Worker extends Person
{
	Worker(String name)
	{
		super(name);
	}
}

　　程序的运行结果如下图：

七、总结

　1.类上定义泛型只有两种情况，泛型类和泛型实例类，即为 class 类名<T> {}和class 类名<具体数据类型> {},且格式唯一。方法上定义泛型只有一种情况，就是在返回值类型前加泛型<T>。

　2.对于泛型参数类，类中的内容都可以引用该泛型参数，但不包括静态方法，因为静态方法先于对象存在。对于泛型实例类，如果某个数据类型被实例化，例如class 类名<String> { 类的内容 }，则表示将类中String类型提升为Object类型，在类中String对象不能使用其特有方法，且静态方法中不能存在String对象。对于泛型方法中的泛型参数只能在方法上或方法内中引用。如果类中出现了泛型参数，但在方法和类上都没有定义泛型，则编译不通过。

　3.泛型限定中的泛型参数必须在方法中或类中有定义，否则不通过。泛型实例和通配符只能出现在定义了泛型的类或接口名上。

　4.泛型类型的对象和通配符对象不能调用其特有方法，只能调用Object类中的方法。

　5.通配符？只能作为泛型的占位符使用，表示不确定接受类型。不能作为参数数据类型进行引用。

　6.泛型的问题：为了方便说明问题，假定存在三个类，分别为Person、Teacher、Student，且存在Student继承Teacher，而Teacher继承Person的关系。

　　1）<T super 具体数据类型>,如<T super Student>,是不允许出现这种格式的。　　

　　　示例1：public <T superStudent> void print(Collection<T > coll){}：错误格式。

　　　示例2：public <T> voidprint(Collection<T super Student> coll){}：错误格式。

　　2）<T extends 具体数据类型>,如<T extendsPerson>，只能出现在泛型方法定义上。

　　　示例1：public <T> voidprint(Collection<T extends Person> coll){}：<Textends Person>没有出现在泛型方法定义中，而是在其他地方，所以格式错误。

　　　示例2：public <T extends Person>void print(Collection<T > coll){}：<T extends Person>出现在泛型方法定义上，所以格式正确。

　　3）<? super T>和<? extends T>不能用来定义泛型类、泛型接口和泛型方法。

　　　示例1：public<? extends T> void print(Collection<T > coll){}：<? extends T>不能用来定义泛型方法，格式错误。

　　　示例2：public <T> voidprint(Collection<? extends T> coll){}：格式正确。

　　　示例3 : public <? super T> void print(Collection<T> coll){}: <? super T>不能用来定义泛型方法，格式错误。

　　　示例4：public <T> void print(Collection<?super T> coll){}：格式正确。

　　4） <? super T>、<? extends T>和<T>必须依赖于泛型类或泛型接口或泛型方法而存在，应为泛型参数T必须要进行定义。

　　　在泛型方法中，下面三种写法在泛型限定上是等效的，即接收的类型都为Person或Person的子类。

　　　　格式1：public <T extends Person> voidprint(Collection<? super T> coll){} 

　　　　格式2：public <T extends Person> voidprint(Collection<T> coll){}

　　　　格式3：public <T extends Person> voidprint(Collection<? extends T> coll){}

　　　在泛型类或接口中，下面三种写法在泛型限定上是不同的。

　　　例如：存在一个泛型类A<T>,包含三种格式，如下：　　　　

 　　　　classA<T>

　　　　{

　　　　格式1：public void print(Collection<? super T> coll){} :当newA<Student>时，print方法只能接收泛型为Student或Student的父类的集合。

　　　　格式2：public void print(Collection<T> coll){}：当newA<Student>时，print方法只能接收泛型为Student的集合。

　　　　格式3：public void print(Collection<? extends T> coll){}：当new A<Student>时，print方法只能接收泛型为Student或Student的子类的集合。

　　　　}

　　5）<?super 具体数据类型>、<? extends 具体数据类型>和<具体数据类型>不需要依赖于泛型类或泛型接口或泛型方法而存在，因为三种都不存在泛型参数，因此不需要进行定义。　　

　　6）类型不兼容问题。

　　　情况1：ArrayList<String> al=new ArrayList<Object>();

　　　情况2：ArrayList<Object> al=new ArrayList<String>();

　　7）编译出现安全提醒。

　　　情况１：ArrayList<String> al=new ArrayList();

　　注：ArrayList al=new ArrayList<String>();不出现安全提醒，因为泛型是jdk1.5版本出现的，老版本应该容纳新版本。