关于泛型的认识和理解

今天学习了泛型的知识，以前在看毕向东老师的视频时，开始提到泛型，我的理解以为是上帝类Object呢。

今天看完高新视频后，对泛型有了新的理解。于是找了泛型的知识的特点。

在Java1.5后引入了泛型的概念。

 泛型的本质是参数化类型，也可以说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。     
泛型的好处：
1. 可以在编译时检查存储的数据是否正确。我们开发有一个趋向就是尽早的发现错误，最好就是在编译阶段， 泛型正好符合这一条件。 把问题交给程序员处理，而不是用户。
2. 减少了强制转换， String str = (String)strList.get(0）；这样的操作属于一种向下转型， 是比较危险的操作， 当List内存储的对象不适String时就会抛出异常。

泛型类和泛型的方法 

package com.cn.fanxing;

public class Generic
{
	public static void main(String args[])
	{
		GenericFx<Integer> g1=new GenericFx<Integer>();
		GenericFx<Boolean> g2=new GenericFx<Boolean>();
		g1.setFx(10);
		System.out.println(g1.getFx());
		g2.setFx(new Boolean(true));
		System.out.println(g2.getFx());
		Print.println("My Test");
		Print.println(007);
	}
}
class GenericFx<T>//泛型类
{
	private T Fx;
	public void setFx(T Fx)
	{
		this.Fx=Fx;
	}
	public T getFx()
	{
		return Fx;
	}	
}
class Print
{
	public static <T> void println(T t)//泛型方法
	{
		System.out.println("println"+"...."  +t);
	}
}

泛型使用时上限和下限

package com.cn.fanxing;

import java.util.ArrayList;
import java.util.List;
class Toy
{

}

class SubToy extends Toy
{

}

class SubToy2 extends Toy
{

}
public class Generics
{

	public static void main(String[] args) throws Exception
	{
		Toy toy = new Toy();
		SubToy subToy = new SubToy();
		SubToy subToy2 = new SubToy();

		List<? extends Toy> list = new ArrayList<Toy>();// 表示所持有对象是Toy子类
		List<? extends Toy> list1 = new ArrayList<SubToy>();// 表示所持有对象是Toy的子类

		// list.add(toy); 错误的 因为list所持有的对象类型上限为Toy，但是他不知道具体持有的对象类型，
		// list.add(subToy); 错误的，理由同上
		// list.add(subToy2); 错误的，理由同上

		// list1.add(toy); 错误的 因为list1所持有的对象类型上限为Toy，但是他不知道具体持有的对象类型，
		// list1.add(subToy); 错误的，理由同上
		// list1.add(subToy2); 错误的，理由同上

		List<? super Toy> list2 = new ArrayList<Toy>();// 所持有对象为Toy的超类,下限为Toy，所以可以add()
														// Toy及Toy的子类
		list2.add(toy);
		list2.add(subToy);
		list2.add(subToy2);

		// List<? super Toy> list3 = new ArrayList<SubToy>();
		// 错误的，所持有对象为Toy的超类，下限为Toy，
		// 所以不可以超过下限Toy，将ArrayList泛型指定为SubToy

		List<? super SubToy> list4 = new ArrayList<Toy>();// 所持有对象为SubToy的超类，下限为SubToy
															// ，
															// 可以将ArrayList泛型指定为Toy
															// list4.add(toy);
															// 错误的，因为虽然持有对象为SubToy的超类，但是容器不知道具体的类型是超类还是子类，所以不能放入超类，但是子类的话就可以的
		list4.add(subToy);
		list4.add(subToy2);

		List<? super SubToy> list5 = new ArrayList<SubToy>();// 所持有对象为SubToy的超类，下限为SubToy
																// ，
		// 可以将ArrayList泛型指定为SubToy
		// list5.add(toy); 错误的，理由同list4
		list5.add(subToy);
		list5.add(subToy2);

		// List<? super SubToy> list6 = new ArrayList<SubToy2>();
		// 错误的，所持有对象为SubToy的超类，下限为SubToy ，
		// 所以持有的对象可能为Toy，也可能为SubToy ，也就不能将具体的实现的泛型指定为SubToy2

	}

}