A. java泛型類和泛型方法
1、什麼是泛型？
泛型簡言之就是類型參數化，不指定類型，運行時傳入類型。
如果業務需求有沒有可能不指定類型？有沒有可能在運行時才知道具體的類型是什麼？
所以，就出現了泛型。
public class Container<K, V> {
private K key;
private V value;
public Container(K k, V v) {
key = k;
value = v;
}
public K getKey() {
return key;
}
public void setKey(K key) {
this.key = key;
}
public V getValue() {
return value;
}
public void setValue(V value) {
this.value = value;
}
}
在編譯期，是無法知道K和V具體是什麼類型，只有在運行時才會真正根據類型來構造和分配內存。這就是泛型。
B. java 泛型 T的類型
"<T>"可以代表任意類型的。
解釋： 「<T>」是泛型的默認值，可以被任意類型所代替，如：
List<String> list = new ArayList<String>()；這個就定義了一個String類型的數組，那麼T的類型就是字元串。
List<T> list = new ArayList<T>()；之後也有可以：list.add("StringBatch");
這個時候T的類型也是String。也就是說T是動態的，可以被任意指定類型。
C. java泛型
java泛型是1.5引進的一個新概念.
本題對於"? super T"和"? extends T",我從書上摘個經典的例子給你看看,如果不能理解,那麼你就參考以下書籍慢慢體會,循序漸進!
"? super T"和"? extends T",都是java泛型通配符,而用法又有區別,
還有super 和extends 不是java類關系中的超類和繼承的意思,他是通配符的下限和上限限制.
下面看一個通配符得高級用法:
在這一部分，我們來考慮一些通配符得高級用法。我們已經看到了上限通配符在從一個數據結構中進行讀取的幾個例子。現在考慮相反的情況，一個只寫的數據結構。
介面Sink是這種情況的一個簡單例子。
interface Sink<T> {
void flush(T t);
}
我們可以想像他被如下面的代碼一樣使用。方法writeAll() 被設計來把集合coll的所有元素flush到sink snk，並且返回最後一個flush的元素。
public static <T> T writeAll(Collection<T> coll, Sink<T> snk) {
T last = null;
for (T t : coll) {
last = t;
snk.flush(last);
}
return last;
}
Sink<Object> s;
Collection<String> cs;
String str = writeAll(cs, s); // 非法的調用!!
像上面所寫，writeAll() 的調用是非法的，因為沒有有效的類型參數可以被推斷出來。String 或 Object都不是T的合適的類型，因為Collection的元素和 Sink的元素必須是同樣的類型。
我們可以解決這個問題，通過使用通配符來修改writeAll()的方法簽名，如下：
<T> T writeAll(Collection<? extends T> coll, Sink<T> snk) { … }
String str = writeAll(cs, s); //可以調用但是返回值類型錯誤
這個調用現在是合法的，但是賦值產生錯誤，因為推斷出的返回值類型是 Object因為T 匹配了Sink的類型，Object。
解決方案是使用一種我們還沒有見過的有限制的通配符：有下限的通配符。語法 ? super T 表示T的一個未知的父類（或者是T自己）。這跟我們用? extends T 表示T的一個未知的子類是對應的。
<T> T writeAll(Collection<T> coll, Sink<? super T> snk) { … }
String str = writeAll(cs, s); // YES!!!
使用這個語法，這個調用是合法的，推斷出來的T是String，正是我們想要的。
現在讓我們看一個更現實的例子。一個 java.util.TreeSet<E> 代表一個有序的元素是E類型的樹。創建一個TreeSet的一個方法是傳遞一個 Comparator 對象給構造函數。這個Comparator將會用來按照需要對TreeSet進行排序。
TreeSet(Comparator<E> c)
Comparator 介面是核心：
interface Comparator<T> { int compare(T fst, T snd); }
假定我們要創建一個 TreeSet<String> 並傳遞一個合適的 Comparator，我們需要傳一個能比較String的Comparator。這可以是一個 Comparator<String>，也可以是一個 Comparator<Object>。然而我們不能用Comparator<Object>來調用上面的構造函數。我們可以使用一個有下限的通配符來得到我們需要的靈活性：
TreeSet(Comparator<? super E> c)
這允許任何可用的Comparator被傳遞進去。
作為使用下限通配符最終的例子，讓我們來看看方法 Collections.max()，它返回一個集合中的最大的元素。
現在，為了讓max()能工作，傳進來的集合中的所有元素必須實現 Comparatable介面。而且，他們必須都能夠被彼此比較（all be comparable to each other）。第一個嘗試是：
public static <T extends Comparable<T>> T max(Collection<T> coll)
就是說，方法的參數是某一個能和自己進行比較的T的集合。這限制太嚴格了。
為什麼？考慮一個能和任何對象進行比較的類型：
class Foo implements Comparable<Object> {...} ...
Collection<Foo> cf = ...;
Collections.max(cf); // 應該能工作
cf 中的每個元素都可以和每個cf中的其他元素進行比較，因為每個這樣的元素都是一個Foo,它可以和任意的對象進行比較，也可以和另一個Foo進行比較。
但是，使用上面的方法簽名，我們發現這個調用被拒絕。推斷出來的類型必須是Foo，但是Foo沒有實現介面 Comparable<Foo>。
T 精確的(exactly)和自己能比較是不需要的。所需要的是 T能夠和它的父類中的一個進行比較，這導出：（註：Collections.max()的實際方法簽名更復雜，我們在第10部分再討論。）
public static <T extends Comparable<? super T>> T max(Collection<T> coll)
這個推論對大多數想讓 Comparable 對任意類型生效的用法中都有效：你總是應該使用 Comparable<? super T>。
總之，如果你有一個只使用類型參數T作為參數的API，它的使用應該利用下限通配符( ? super T )的好處。相反的，如果API只返回T，你應該使用上限通配符( ? extends T )來給你的客戶端更大的靈活性。
（原文：This reasoning applies to almost any usage of Comparable that is intended to work for arbitrary types: You always want to use Comparable<? super T>.
In general, if you have an API that only uses a type parameter T as an argument, its uses should take advantage of lower bounded wildcards (? super T). Conversely, if the API only returns T, you'll give your clients more flexibility by using upper bounded wildcards (? extends T). ）。
如果你想比較深刻的了解java泛型那麼
建議你看看<Java1.5泛型指南>
中文鏈接地址:http://blog.csdn.net/explorers/archive/2005/08/15/454837.aspx#_Toc111865968
英文pdf格式地址:http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf
D. java怎麼得到泛型的類型
泛型，就是廣泛的類型。剛開始要用到哪個都不會知道。只有去實例化對象的時候才能確定。泛型的參數只能是對象類型。
你這個程序，T entity-entity就是是一個泛型的引用,你可以在構造方法中為其具體賦值.
例如:
private T entity;
public HibernateDao(T entity)
{this.entity=entity;}
HibernateDao<Strng> h=new HibernateDao<String>("哈哈");
這時,泛型就代表一個String對象.值是哈哈.
在沒有泛型之前,這種形式一般都是先定義一個通用的Object obj.然後在構造方法中為其賦值.
E. java 泛型類創建對象
括弧是說明調用你的類的構造方法，
如果你在定義構造方法的時候指定需要參數，括弧里必須傳參數進去；
如果你的構造方法沒有參數，那麼括弧里可以不寫