java高新技術：泛型

java泛型定義：

好處：

1、将運作時期的問題ClassCastException問題轉換成了編譯失敗，展現在編譯時期，程式員就可以解決問題。

2、避免了強制轉換的麻煩。

隻要帶有<>的類或者接口，都屬于帶有類型參數的類或者接口，在使用這些類或者接口時，必須給<>中傳遞一個具體的引用資料類型。

泛型技術：其實應用在編譯時期，是給編譯器使用的技術，到了運作時期，泛型就不存在了。

為什麼? 因為泛型的擦除：也就是說，編輯器檢查了泛型的類型正确後，在生成的類檔案中是沒有泛型的。

在運作時，如何知道擷取的元素類型而不用強轉呢？

泛型的補償：因為存儲的時候，類型已經确定了是同一個類型的元素，是以在運作時，隻要擷取到該元素的類型，在内部進行一次轉換即可，是以使用者不用再做轉換動作了。

什麼時候用泛型類呢？

當類中的操作的引用資料類型不确定的時候，以前用的Object來進行擴充的，現在可以用泛型來表示。這樣可以避免強轉的麻煩，而且将運作問題轉移到的編譯時期。

----------------------------------------------------------

泛型在程式定義上的展現：

//泛型類：将泛型定義在類上。

class Tool<Q> {

    private Q obj;

    public  void setObject(Q obj) {

        this.obj = obj;

    }

    public Q getObject() {

        return obj;

    }

}

//當方法操作的引用資料類型不确定的時候，可以将泛型定義在方法上。

    public <W> voidmethod(W w) {

        System.out.println("method:"+w);

    }

//靜态方法上的泛型：靜态方法無法通路類上定義的泛型。如果靜态方法操作的引用資料類型不确定的時候，必須要将泛型定義在方法上。

    public static<Q> void function(Q t) {

        System.out.println("function:"+t);

    }

//泛型接口.

interface Inter<T> {

    void show(T t);

}

class InterImpl<R> implements Inter<R> {

    public void show(R r) {

        System.out.println("show:"+r);

    }

}

------------------------------------------------------------

泛型中的通配符：可以解決當具體類型不确定的時候，這個通配符就是?  ；當操作類型時，不需要使用類型的具體功能時，隻使用Object類中的功能。那麼可以用 ? 通配符來表未知類型。

泛型限定：

    上限：？extends E：可以接收E類型或者E的子類型對象。

    下限：？super E：可以接收E類型或者E的父類型對象。

上限什麼時候用：往集合中添加元素時，既可以添加E類型對象，又可以添加E的子類型對象。為什麼？因為取的時候，E類型既可以接收E類對象，又可以接收E的子類型對象。

下限什麼時候用：當從集合中擷取元素進行操作的時候，可以用目前元素的類型接收，也可以用目前元素的父類型接收。

例：

import java.util.*;
class  TreeSetTest2
{
	public static void main(String[] args) 
	{
		TreeSet<String> ts = new TreeSet<String>(new MyCompare());		//讓集合一初始化就具備了排序的功能
		ts.add("zhangsna");
		ts.add("zhangs");
		ts.add("zhanga");
		ts.add("zh");
		ts.add("zha");
		ts.add("zhang");

		Iterator it = ts.iterator();

		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}
				
class MyCompare implements Comparator<String>				//使用泛型，避免了強轉，但是複寫equals方法時，必須強轉，因為Object方法沒有泛型功能
{
	public int compare(String o1,String o2)
	{
		
		int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
		if(num==0)			//如果字元串長度相同，則判斷二次條件
			return o1.compareTo(o2);
		return num;
	}
}
           

泛型的進階應用：

/*
泛型進階應用
? :通配符，也可以了解為占位符
泛型的限定：
	? extends E:可以接收E類或者E的子類型。上限
	? super E ：可以收E類或者E的父類型。下限
*/
import java.util.*;
class GenericDemo2 
{
	public static void main(String[] args) 
	{
		/*
		ArrayList<String> a1 = new ArrayList<String>();

			a1.add("abc");
			a1.add("abcd");
			a1.add("abcde");

		ArrayList<Integer> a2 = new ArrayList<Integer>();
			a2.add(5);
			a2.add(8);
			a2.add(9);

		printColl(a1);
		printColl(a2);
		*/
//----------------------------------------------------------------
		TreeSet<person> a3 = new TreeSet<person>(new Comp());

			a3.add(new person("zhangsan02"));
			a3.add(new person("zhangsan01"));
			a3.add(new person("zhangsan03"));
			a3.add(new person("zhangsan06"));
			a3.add(new person("zhangsan04"));
			a3.add(new person("zhangsan05"));

			printperson(a3);


		TreeSet<Student> a4 = new TreeSet<Student>(new Comp());		//person和Student都調用同一個函數，而如果把這個函數定義成這兩種類型都可以接收進來，
																//那麼兩個都可以使用了
			a4.add(new Student("lisi07"));
			a4.add(new Student("lisi05"));
			a4.add(new Student("lisi03"));

			printperson(a4);


		
	}
//----------------------------------------------------------------

	/*
	public static void printColl(ArrayList<?> a1)
	{
		Iterator<?> it = a1.iterator();
		while (it.hasNext())
		{
			System.out.println(it.next());
		}
	}
	*/
	
	public static void printperson(TreeSet<? extends person> a1)	//定義成person類和其子類都可以使用，上限
	{
		Iterator<? extends person> it = a1.iterator();
		while (it.hasNext())
		{
			System.out.println(it.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);
	}
}
class Comp implements Comparator <person>		//Comparator可以使用E或者E的父類型，定義成父類型，其子類都可以使用
{
	public int compare(person p1,person p2)
	{
		return p1.getName().compareTo(p2.getName());
	}
}
           

泛型的細節：

1、泛型到底代表什麼類型取決于調用者傳入的類型，如果沒傳，預設是Object類型；

2、使用帶泛型的類建立對象時，等式兩邊指定的泛型必須一緻；

    原因：編譯器檢查對象調用方法時隻看變量，然而程式運作期間調用方法時就要考慮對象具體類型了；

3、等式兩邊可以在任意一邊使用泛型，在另一邊不使用(考慮向後相容)；

ArrayList<String>al = new ArrayList<Object>();  //錯

//要保證左右兩邊的泛型具體類型一緻就可以了，這樣不容易出錯。

ArrayList<?extends Object> al = new ArrayList<String>();