第十二：泛型(下)

一：

受限制的类型参数

泛型机制允许开发者对类型参数进行附加约束(T extends List............)

public class ListGenericFoo<T extends List> {
	private T[] fooArray;

	public T[] getFooArray() {
		return fooArray;
	}

	public void setFooArray(T[] fooArray) {
		this.fooArray = fooArray;
	}

	public static void main(String[] args) {
		ListGenericFoo<LinkedList> foo1 = new ListGenericFoo<LinkedList>();
		ListGenericFoo<ArrayList> foo2 = new ListGenericFoo<ArrayList>();

		LinkedList[] linkedList = new LinkedList[10];
		foo1.setFooArray(linkedList);

		ArrayList[] arrayList = new ArrayList[10];
		foo2.setFooArray(arrayList);
		
		//HashMap不是List的子类或者实现类
		//ListGenericFoo<HashMap> foo3=new ListGenericFoo<HashMap>();
	}
}

二：

自己实现一个简单的集合

//自己实现一个简单的集合 
public class SimpleCollection<T extends Object> {
	private T[] objArr;// 数组

	private int index = 0;

	public SimpleCollection() {
		objArr = (T[]) new Object[10];// 初始化这个数组...默认大小为10
	}

	public SimpleCollection(int capacity) {
		objArr = (T[]) new Object[capacity];// 给定大小初始化数组
	}

	// 添加一个元素
	public void add(T t) {
		objArr[index] = t;
		index++;
	}

	// 获取集合中有多少元素
	public int getLength() {
		return index;
	}

	// 获取指定的元素
	public T get(int i) {
		return objArr[i];
	}

	//获取此集合的大小
	public int size(){
		return objArr.length;
	}
	public static void main(String args[]) {
		SimpleCollection<Integer> c = new SimpleCollection<Integer>();
		for (int i = 0; i < 10; i++) {
			System.out.println("<<<<<<<<<<<<<<<<<<<<<<"+c.getLength());
			System.out.println(">>>>>>>>>>>>>>>>>>>>>>"+c.size());
			c.add(new Integer(i));// 自动装箱与自动拆箱
		}
		for (int i = 0; i < 10; i++) {
			System.out.println(c.get(i));
		}
	}
}

三：

灵活应用，思路清晰！！！

四：

通过引入泛型，我们将获得编译时类型的安全和运行时更小地抛出ClassCastExceptions的可能。

五：

GenericTest.java中的问题：》》》》》》》》》》》》》》》》》》重点理解！！！！！！！！

使用<?>或是<? extends SomeClass>的声明方式，意味著您只能通过该名称來取得所参考实例的信息，
或者是移除某些信息(设置为null)，但不能增加它的信息，因为只知道当中放置的是SomeClass的子类，
但不确定是什么类的实例，编译器不让您加入信息，理由是，如果可以加入信息的話，那么您就得記得取回的实例是什么类型，

然后转换为原來的类型方可进行操作，这就失去了使用泛型的意义。

public class GenericTest<T> {
	private T foo;

	public T getFoo() {
		return foo;
	}

	public void setFoo(T foo) {
		this.foo = foo;
	}

	public static void main(String[] args) {
		GenericTest<? extends List> ge = null;
		ge = new GenericTest<ArrayList>();
		ge = new GenericTest<LinkedList>();
		// ge=new GenericTest<HashMap>();//把它限制了

		GenericTest<?> g = null;
		g = new GenericTest<HashMap>();

		GenericTest<? super List> ge2 = null;// 这个啥意思...List以及List上面的！！！
		ge2 = new GenericTest<Object>();
		// ge2=new GenericTest<ArrayList>();//把它限制了

		GenericTest<String> ge3 = new GenericTest<String>();
		ge3.setFoo("hello world");

		GenericTest<? extends Object> ge4 = ge3;
		System.out.println(ge4.getFoo());
		ge4.setFoo(null);//只能设置为null，不能设置为其他值...注意...
		// 因为你不知道是什么类型,如果你知道是什么类型，那就失去泛型类型参数化的意义了!
		System.out.println(ge4.getFoo());
		// ge4.setFoo("welcome");//这里为什么不行？？？重点理解！！！！！！

	}
}

六：

泛型类的继承

泛型类实现泛型接口

补充问题：我现在总结的一点小结论
1.在创建一个类的时候用T(绝对不可以使用？)
2.？可以在实例化对象和方法(参数)中使用