java泛型原理

Ⅰ 你真的了解java中的泛型E、T、K、V嗎

Java 泛型（generics）是 JDK 5 中引入的一個新特性, 泛型提供了編譯時類型安全檢測機制，該機制允許開發者在編譯時檢測到非法的類型。泛型的本質是參數化類型，也就是說所操作的數據類型被指定為一個參數。

但是如果換成其他的字母代替 T ，在可讀性上可能會弱一些。通常情況下，T，E，K，V，？是這樣約定的：？表示不確定的 java 類型。T (type) 表示具體的一個java類型。K V (key value) 分別代表java鍵值中的Key Value。E (element) 代表Element。

Ⅱ 對java泛型的理解

泛型的定義主要有以下兩種：

在程序編碼中一些包含類型參數的類型，也就是說泛型的參數只可以代表類，不能代表個別對象。（這是當今較常見的定義）

在程序編碼中一些包含參數的類。其參數可以代表類或對象等等。（現在人們大多把這稱作模板）

泛型的好處是在編譯的時候檢查類型安全，並且所有的強制轉換都是自動和隱式的，提高代碼的重用率。

泛型只不過是java中的類型而已，繼承自Type介面。

Ⅲ 請教關於java的泛型方法

Java泛型詳解

1. 概述
   在引入范型之前，Java類型分為原始類型、復雜類型，其中復雜類型分為數組和類。引入范型後，一個復雜類型
   就可以在細分成更多的類型。
   例如原先的類型List，現在在細分成List<Object>, List<String>等更多的類型。
   注意，現在List<Object>, List<String>是兩種不同的類型，
   他們之間沒有繼承關系，即使String繼承了Object。下面的代碼是非法的
   List<String> ls = new ArrayList<String>();
   List<Object> lo = ls;
   這樣設計的原因在於，根據lo的聲明，編譯器允許你向lo中添加任意對象（例如Integer），但是此對象是
   List<String>，破壞了數據類型的完整性。
   在引入范型之前，要在類中的方法支持多個數據類型，就需要對方法進行重載，在引入范型後，可以解決此問題
   （多態），更進一步可以定義多個參數以及返回值之間的關系。
   例如
   public void write(Integer i, Integer[] ia);
   public void write(Double d, Double[] da);
   的范型版本為
   public <T> void write(T t, T[] ta);
   
   2. 定義&使用
   類型參數的命名風格為：
   推薦你用簡練的名字作為形式類型參數的名字(如果可能，單個字元)。最好避免小寫字母，這使它和其他的普通
   的形式參數很容易被區分開來。
   使用T代表類型，無論何時都沒有比這更具體的類型來區分它。這經常見於泛型方法。如果有多個類型參數，我們
   可能使用字母表中T的臨近的字母，比如S。
   如果一個泛型函數在一個泛型類裡面出現，最好避免在方法的類型參數和類的類型參數中使用同樣的名字來避免混
   淆。對內部類也是同樣。
   
   2.1 定義帶類型參數的類
   在定義帶類型參數的類時，在緊跟類命之後的<>內,指定一個或多個類型參數的名字，同時也可以對類型參數的取
   值范圍進行限定，多個類型參數之間用,號分隔。
   定義完類型參數後，可以在定義位置之後的類的幾乎任意地方（靜態塊，靜態屬性，靜態方法除外）使用類型參數，
   就像使用普通的類型一樣。
   注意，父類定義的類型參數不能被子類繼承。
   public class TestClassDefine<T, S extends T> {
   ....
   }
   
   2.2 定義待類型參數方法
   在定義帶類型參數的方法時，在緊跟可見范圍修飾（例如public）之後的<>內,指定一個或多個類型參數的名字，同時也可以對類型參數的取值范圍進行限定，多個類型參數之間用,號分隔。
   定義完類型參數後，可以在定義位置之後的方法的任意地方使用類型參數，就像使用普通的類型一樣。
   例如：
   public <T, S extends T> T testGenericMethodDefine(T t, S s){
   ...
   }
   注意：定義帶類型參數的方法，騎主要目的是為了表達多個參數以及返回值之間的關系。例如本例子中T和S的繼承關系， 返回值的類型和第一個類型參數的值相同。
   如果僅僅是想實現多態，請優先使用通配符解決。通配符的內容見下面章節。
   public <T> void testGenericMethodDefine2(List<T> s){
   ...
   }
   應改為
   public void testGenericMethodDefine2(List<？> s){
   ...
   }
   
   3. 類型參數賦值
   當對類或方法的類型參數進行賦值時，要求對所有的類型參數進行賦值。否則，將得到一個編譯錯誤。
   
   3.1 對帶類型參數的類進行類型參數賦值
   對帶類型參數的類進行類型參數賦值有兩種方式
   第一聲明類變數或者實例化時。例如
   List<String> list;
   list = new ArrayList<String>;
   第二繼承類或者實現介面時。例如
   public class MyList<E> extends ArrayList<E> implements List<E> {...}
   
   3.2 對帶類型參數方法進行賦值
   當調用范型方法時，編譯器自動對類型參數進行賦值，當不能成功賦值時報編譯錯誤。例如
   public <T> T testGenericMethodDefine3(T t, List<T> list){
   ...
   }
   public <T> T testGenericMethodDefine4(List<T> list1, List<T> list2){
   ...
   }
   
   Number n = null;
   Integer i = null;
   Object o = null;
   testGenericMethodDefine(n, i);//此時T為Number, S為Integer
   testGenericMethodDefine(o, i);//T為Object, S為Integer
   
   List<Number> list1 = null;
   testGenericMethodDefine3(i, list1)//此時T為Number
   
   List<Integer> list2 = null;
   testGenericMethodDefine4(list1, list2)//編譯報錯
   
   3.3 通配符
   在上面兩小節中，對是類型參數賦予具體的值，除此，還可以對類型參數賦予不確定值。例如
   List<?> unknownList;
   List<? extends Number> unknownNumberList;
   List<? super Integer> unknownBaseLineIntgerList;
   注意： 在Java集合框架中，對於參數值是未知類型的容器類，只能讀取其中元素，不能像其中添加元素，因為，其類型是未知，所以編譯器無法識別添加元素的類型和容器的類型是否兼容，唯一的例外是NULL
   
   List<String> listString;
   List<?> unknownList2 = listString;
   unknownList = unknownList2;
   listString = unknownList;//編譯錯誤
   
   4. 數組范型
   可以使用帶范型參數值的類聲明數組，卻不可有創建數組
   List<Integer>[] iListArray;
   new ArrayList<Integer>[10];//編譯時錯誤
   
   5. 實現原理
   
   5.1. Java范型時編譯時技術，在運行時不包含范型信息，僅僅Class的實例中包含了類型參數的定義信息。
   泛型是通過java編譯器的稱為擦除(erasure)的前端處理來實現的。你可以（基本上就是）把它認為是一個從源碼到源碼的轉換，它把泛型版本轉換成非泛型版本。
   基本上，擦除去掉了所有的泛型類型信息。所有在尖括弧之間的類型信息都被扔掉了，因此，比如說一個List<String>類型被轉換為List。所有對類型變數的引用被替換成類型變數的上限(通常是Object)。而且，無論何時結果代碼類型不正確，會插入一個到合適類型的轉換。
   <T> T badCast(T t, Object o) {
   return (T) o; // unchecked warning
   }
   類型參數在運行時並不存在。這意味著它們不會添加任何的時間或者空間上的負擔，這很好。不幸的是，這也意味著你不能依靠他們進行類型轉換。
   
   5.2.一個泛型類被其所有調用共享
   下面的代碼列印的結果是什麼？
   List<String> l1 = new ArrayList<String>();
   List<Integer> l2 = new ArrayList<Integer>();
   System.out.println(l1.getClass() == l2.getClass());
   或許你會說false，但是你想錯了。它列印出true。因為一個泛型類的所有實例在運行時具有相同的運行時類(class)，
   而不管他們的實際類型參數。
   事實上，泛型之所以叫泛型，就是因為它對所有其可能的類型參數，有同樣的行為；同樣的類可以被當作許多不同的類型。作為一個結果，類的靜態變數和方法也在所有的實例間共享。這就是為什麼在靜態方法或靜態初始化代碼中或者在靜態變數的聲明和初始化時使用類型參數（類型參數是屬於具體實例的）是不合法的原因。
   
   5.3. 轉型和instanceof
   泛型類被所有其實例(instances)共享的另一個暗示是檢查一個實例是不是一個特定類型的泛型類是沒有意義的。
   Collection cs = new ArrayList<String>();
   if (cs instanceof Collection<String>) { ...} // 非法
   類似的，如下的類型轉換
   Collection<String> cstr = (Collection<String>) cs;
   得到一個unchecked warning，因為運行時環境不會為你作這樣的檢查。
   
   6. Class的范型處理
   Java 5之後，Class變成范型化了。
   JDK1.5中一個變化是類 java.lang.Class是泛型化的。這是把泛型擴展到容器類之外的一個很有意思的例子。
   現在，Class有一個類型參數T, 你很可能會問，T 代表什麼？它代表Class對象代表的類型。比如說，
   String.class類型代表 Class<String>，Serializable.class代表 Class<Serializable>。
   這可以被用來提高你的反射代碼的類型安全。
   特別的，因為 Class的 newInstance() 方法現在返回一個T, 你可以在使用反射創建對象時得到更精確的類型。
   比如說，假定你要寫一個工具方法來進行一個資料庫查詢，給定一個SQL語句，並返回一個資料庫中符合查詢條件
   的對象集合(collection)。
   一個方法是顯式的傳遞一個工廠對象，像下面的代碼：
   interface Factory<T> {
   public T[] make();
   }
   public <T> Collection<T> select(Factory<T> factory, String statement) {
   Collection<T> result = new ArrayList<T>();
   /* run sql query using jdbc */
   for ( int i=0; i<10; i++ ) { /* iterate over jdbc results */
   T item = factory.make();
   /* use reflection and set all of item』s fields from sql results */
   result.add( item );
   }
   return result;
   }
   你可以這樣調用：
   select(new Factory<EmpInfo>(){
   public EmpInfo make() {
   return new EmpInfo();
   }
   } , 」selection string」);
   也可以聲明一個類 EmpInfoFactory 來支持介面 Factory：
   class EmpInfoFactory implements Factory<EmpInfo> { ...
   public EmpInfo make() { return new EmpInfo();}
   }
   然後調用：
   select(getMyEmpInfoFactory(), "selection string");
   這個解決方案的缺點是它需要下面的二者之一：
   調用處那冗長的匿名工廠類，或為每個要使用的類型聲明一個工廠類並傳遞其對象給調用的地方，這很不自然。
   使用class類型參數值是非常自然的，它可以被反射使用。沒有泛型的代碼可能是：
   Collection emps = sqlUtility.select(EmpInfo.class, 」select * from emps」); ...
   public static Collection select(Class c, String sqlStatement) {
   Collection result = new ArrayList();
   /* run sql query using jdbc */
   for ( /* iterate over jdbc results */ ) {
   Object item = c.newInstance();
   /* use reflection and set all of item』s fields from sql results */
   result.add(item);
   }
   return result;
   }
   但是這不能給我們返回一個我們要的精確類型的集合。現在Class是泛型的，我們可以寫：
   Collection<EmpInfo> emps=sqlUtility.select(EmpInfo.class, 」select * from emps」); ...
   public static <T> Collection<T> select(Class<T>c, String sqlStatement) {
   Collection<T> result = new ArrayList<T>();
   /* run sql query using jdbc */
   for ( /* iterate over jdbc results */ ) {
   T item = c.newInstance();
   /* use reflection and set all of item』s fields from sql results */
   result.add(item);
   }
   return result;
   }
   來通過一種類型安全的方式得到我們要的集合。
   這項技術是一個非常有用的技巧，它已成為一個在處理注釋(annotations)的新API中被廣泛使用的習慣用法。
   
   7. 新老代碼兼容
   
   7.1. 為了保證代碼的兼容性，下面的代碼編譯器（javac）允許，類型安全有你自己保證
   List l = new ArrayList<String>();
   List<String> l = new ArrayList();
   
   7.2. 在將你的類庫升級為范型版本時，慎用協變式返回值。
   例如，將代碼
   public class Foo {
   public Foo create(){
   return new Foo();
   }
   }
   
   public class Bar extends Foo {
   public Foo create(){
   return new Bar();
   }
   }
   採用協變式返回值風格，將Bar修改為
   public class Bar extends Foo {
   public Bar create(){
   return new Bar();
   }
   }
   要小心你類庫的客戶端。

Ⅳ java中什麼是泛型，怎麼用泛型

最簡單的運用：List<String> list = new ArrayList<String>();
這個是什麼意思？
意思就是list只裝String類型的數據，別的，裝不進去
然後你版就會覺得這個好權像有點封裝的意思，比如LIst<Student>，封裝學生類
所以，所謂泛型就是廣泛的數據類型，你可以把它理解成封裝

Ⅳ java中泛型指的是什麼

我來簡述一下泛型的知抄識吧:

如果一個類的後面跟上一個尖括弧,表示這個類是泛型類.

可以這樣聲明:class 名稱<泛型列表>
如:class A<E>
其中A是泛型類的名稱,E是泛型.(可以是任何對象或介面)

其中給出的泛型可以作為類的成員變數的類型,方法的類型以及局部變數的類型.類體和變通類完全一樣,由成員變數和方法構成.

舉個例子:
class Chorus<E,F>
{
void makeChorus(E person,F yueqi)
{
yueqi.toString();
person.toString() ;
}
}
--------------
上面的類中將類E和類F作為類Chorus的一部分來使用.這就是泛型類的目的,將多個類包含進一個類來使用!!!

如果你想深入理解就可以找一些書來看,一些基本的教材裡面也都有提到泛型的.

希望我說的對你有所幫助!!!

Ⅵ java泛型深入解釋：public <T> Test<T> tttttt(String s,Bean bean) {}

public<T>Test<T>tttttt(Strings,Beanbean){}

• 第一個<T>是固定語法 可以理解為在這個方法中使用的泛型用符號T表示，當然你也可以用別的名字。

• Test<T> 說明類型Test的定義中也使用了泛型public class Test<T> {}
  

Ⅶ java中泛型是怎麼做到類型安全的

在類定義處聲明的泛型，則用來指定這個類用來處理的對象類型，這個類中定義的所有方法，只要使用了類定義處聲明的泛型參數，則都必須使用同一個對象，否則，編譯就會出現錯誤
如果僅僅是在方法聲明處定義泛型，則表示這個方法的參數或返回值使用什麼類型的數據。
泛型可以確保我們定義的類型是安全的，不會出現轉換出錯問題等。

1.不再需要強制轉型;
2.編輯器增加了強制檢查集合中的對象類型的功能，避免了在Girl的集合中出現Boy對象的問題(雖然有的時候是我們所期待的)
如:
public class Query{
private T t;
public T get(){...};
public void set(T t){...};
}
如果使用的方式如下:
Query query = new Query();
則上面定義的類與下面的定義一致
public class Query{
private User t;
public User get(){...}
public void set(User t){}
}

Ⅷ java中什麼叫泛型

泛型。規定了此集合中元素的類型。例如：

ArrayList<Integer> arr = new ArrayList<Integer> ();

這樣就創建了一個包含整數的 ArrayList 對象。
如果要自己定義泛型類，就用如下形式：

class MyCollection<E> {...}

尖括弧中的類型可以有限制，例如你需要讓 MyCollection 中的類型都具有可比性，可以用如下格式：

class MyCollection<E extends Comparable> {...}

此外，要注意泛型的一些特性：

1. 不能直接創建泛型數組。如 new ArrayList<Integer>[5] 之類的是錯的。只能用如下方法：new ArrayList[5] 或者 (ArrayList<Integer>[])new ArrayList[5];

2. 靜態方法中需要小心，因為 E 一般是非靜態類型，如果你這樣寫：
class MyCollection<E> {
public static MyCollection<E> abc() {
......
}
}
是錯的。你只能把 <E> 去掉。

Ⅸ java中的泛型 求詳細解釋

1、Java泛型
其實Java的泛型就是創建一個用類型作為參數的類。就象我們寫類的方法一樣，方法是這樣的method(String str1,String str2 ),方法中參數str1、str2的值是可變的。而泛型也是一樣的，這樣寫class Java_Generics＜K,V＞，這里邊的K和V就象方法中的參數str1和str2,也是可變。下面看看例子：
//code list 1
import Java.util.Hashtable;
class TestGen0＜K,V＞{
public Hashtable＜K,V＞ h=new Hashtable＜K,V＞();
public void put(K k, V v) {
h.put(k,v);
}
public V get(K k) {
return h.get(k);
}
public static void main(String args[]){
TestGen0＜String,String＞ t=new TestGen0＜String,String＞();
t.put("key", "value");
String s=t.get("key");
System.out.println(s);
}
}
正確輸出:value
這只是個例子（Java中集合框架都泛型化了，這里費了2遍事.），不過看看是不是創建一個用類型作為參數的類，參數是K，V，傳入的「值」是String類型。這個類他沒有特定的待處理型別，以前我們定義好了一個類，在輸入輸入參數有所固定，是什麼型別的有要求，但是現在編寫程序，完全可以不制定參數的類型，具體用的時候來確定，增加了程序的通用性，像是一個模板。
呵呵，類似C++的模板（類似）。
1.1. 泛型通配符
下面我們先看看這些程序：
//Code list 2
void TestGen0Medthod1(List l) {
for (Object o : l)
System.out.println(o);
}
看看這個方法有沒有異議，這個方法會通過編譯的，假如你傳入String，就是這樣List＜String＞。
接著我們調用它,問題就出現了，我們將一個List＜String＞當作List傳給了方法，JVM會給我們一個警告，說這個破壞了類型安全，因為從List中返回的都是Object類型的，而讓我們再看看下面的方法。
//Code list 3
void TestGen0Medthod1(List＜String＞ l) {
for (Object o : l)
System.out.println(o);
}
因為這里的List＜String＞不是List＜Object＞的子類,不是String與Object的關系，就是說List＜String＞不隸屬於list＜Object＞,他們不是繼承關系，所以是不行的，這里的extends是表示限制的。
類型通配符是很神奇的，List＜?＞這個你能為他做什麼呢?怎麼都是「？」，它似乎不確定，他總不能返回一個？作為類型的數據吧，是啊他是不會返回一個「？」來問程序員的？JVM會做簡單的思考的，看看代碼吧，更直觀些。
//code list 4
List＜String＞ l1 = new ArrayList＜String＞();
li.add(「String」);
List＜?＞ l2 = l1;
System.out.println(l1.get(0));
這段代碼沒問題的，l1.get(0)將返回一個Object。
1.2. 編寫泛型類要注意：
1) 在定義一個泛型類的時候，在 「＜＞」之間定義形式類型參數，例如：「class TestGen＜K,V＞」，其中「K」 , 「V」不代表值，而是表示類型。
2) 實例化泛型對象的時候，一定要在類名後面指定類型參數的值（類型），一共要有兩次書寫。例如：
TestGen＜String,String＞ t=new TestGen＜String,String＞()；
3) 泛型中＜K extends Object＞,extends並不代表繼承，它是類型範圍限制。
2、泛型與數據類型轉換
2.1. 消除類型轉換
上面的例子大家看到什麼了，數據類型轉換的代碼不見了。在以前我們經常要書寫以下代碼，如：
//code list 5
import Java.util.Hashtable;
class Test {
public static void main(String[] args) {
Hashtable h = new Hashtable();
h.put("key", "value");
String s = (String)h.get("key");
System.out.println(s);
}
}
這個我們做了類型轉換，是不是感覺很煩的，並且強制類型轉換會帶來潛在的危險，系統可能會拋一個ClassCastException異常信息。在JDK5.0中我們完全可以這么做，如：
//code list 6
import Java.util.Hashtable;
class Test {
public static void main(String[] args) {
Hashtable＜String,Integer＞ h = new Hashtable＜String,Integer＞ ();
h.put("key", new Integer(123));
int s = h.get("key").intValue();
System.out.println(s);
}
}
這里我們使用泛化版本的HashMap,這樣就不用我們來編寫類型轉換的代碼了，類型轉換的過程交給編譯器來處理，是不是很方便，而且很安全。上面是String映射到String，也可以將Integer映射為String，只要寫成HashTable＜Integer,String＞ h=new HashTable＜Integer,String＞();h.get(new Integer(0))返回value。果然很方便。

Ⅹ 什麼叫泛型有什麼作用

泛型。即通過參數化類型來實現在同一份代碼上操作多種數據類型。泛型類和泛型方法同時具備可重用性、類型安全和效率，這是非泛型類和非泛型方法無法具備的。泛型通常用與集合以及作用於集合的方法一起使用。

泛型是c#2.0的一個新增加的特性，它為使用c#語言編寫面向對象程序增加了極大的效力和靈活性。不會強行對值類型進行裝箱和拆箱，或對引用類型進行向下強制類型轉換，所以性能得到提高。

Java 的泛型

Java 泛型的參數只可以代表類，不能代表個別對象。由於Java泛型的類型參數之實際類型在編譯時會被消除，所以無法在運行時得知其類型參數的類叢襪型，而且無法直接使用基本值類型作為泛型類爛薯型參數。Java編譯程序在編譯泛型時會自動加入類型轉換的編碼，故運行速度不會因為使用泛型而加快。

由於運行時會消除泛型的對象實例類型信息等缺陷經常被人詬病，Java及JVM的開發方面也嘗試解決飢鄭者這個問題，例如Java通過在生成位元組碼時添加類型推導輔助信息，從而可以通過反射介面獲得部分泛型信息。通過改進泛型在JVM的實現，使其支持基本值類型泛型和直接獲得泛型信息等。