java泛型class
❶ java 泛型 Class
給你順序解釋下泛型的意思哈：
<T>：定義一個泛型
T ：定義方法返回的類型是之前定義的泛型類型
Class<? extends T> 這個是定義參數的類型為Class， 但是這個Class必須是和之前定義的泛型有繼承關系的。？表示任意類的Class，不過後面跟了extends 表明了條件。
❷ Java 泛型 Class< extends T>
泛型中<? extends T>和<? super T> 差別
<? extends T>和<? super T>含有JAVA5.0的新的概念。由於它們的外表導致了很多人誤解了它們的用途：
1.<?
extends T>首先你很容易誤解它為繼承於T的所有類的集合，這是大錯特錯的，相信能看下去你一定見過或用過List<?
extends T>吧？為什麼我說理解成一個集合是錯呢？如果理解成一個集合那為什麼不用List<T>來表示？所以<?
extends
T>不是一個集合，而是T的某一種子類的意思，記住是一種，單一的一種，問題來了，由於連哪一種都不確定，帶來了不確定性，所以是不可能通過
add（）來加入元素。你或許還覺得為什麼add(T)不行?因為<? extends
T>是T的某種子類，能放入子類的容器不一定放入超類，也就是沒可能放入T。
2.<? super T>這里比較容易使用，沒<? extends T>這么多限制，這里的意思是，以T類為下限的某種類，簡單地說就是T類的超類。但為什麼add(T)可以呢？因為能放入某一類的容器一定可以放入其子類，多態的概念。
擦除
也
許泛型最具挑戰性的方面是擦除（erasure），這是 Java
語言中泛型實現的底層技術。擦除意味著編譯器在生成類文件時基本上會拋開參數化類的大量類型信息。編譯器用它的強制類型轉換生成代碼，就像程序員在泛型出
現之前手工所做的一樣。區別在於，編譯器開始已經驗證了大量如果沒有泛型就不會驗證的類型安全約束。
通過擦除實現泛型的含意是很重要的，並
且初看也是混亂的。盡管不能將List<Integer> 賦給List<Number>，因為它們是不同的類型，但是
List<Integer> 和 List<Number> 類型的變數是相同的類！要明白這一點，請評價下面的代碼：
new List<Number>().getClass() == new List<Integer>().getClass()
編譯器只為 List 生成一個類。當生成了 List 的位元組碼時，將很少剩下其類型參數的的跟蹤。
當
生成泛型類的位元組碼時，編譯器用類型參數的擦除替換類型參數。對於無限制類型參數（<V>），它的擦除是
Object。對於上限類型參數（<K extends Comparable<K>>），它的擦除是其上限（在本例中是
Comparable）的擦除。對於具有多個限制的類型參數，使用其最左限制的擦除。
如果檢查生成的位元組碼，您無法說出 List<Integer> 和 List<String> 的代碼之間的區別。類型限制 T 在位元組碼中被 T 的上限所取代，該上限一般是 Object。
多重限制
一個類型參數可以具有多個限制。當您想要約束一個類型參數比如說同時為 Comparable 和 Serializable 時，這將很有用。多重限制的語法是用「與」符號分隔限制：
class C<T extends Comparable<? super T>&Serializable>
通配符類型可以具有單個限制 —— 上限或者下限。一個指定的類型參數可以具有一個或多個上限。具有多重限制的類型參數可以用於訪問它的每個限制的方法和域。
類型形參和類型實參
在
參數化類的定義中，佔位符名稱（比如 Collection<V> 中的 V）叫做類型形參（type
parameter），它們類似於方法定義中的形式參數。在參數化類的變數的聲明中，聲明中指定的類型值叫做類型實參（type
argument），它們類似於方法調用中的實際參數。但是實際中二者一般都通稱為「類型參數」。所以給出定義：
interface Collection<V> { ... }
和聲明：
Collection<String> cs = new HashSet<String>();
那麼，名稱 V（它可用於整個 Collection 介面體內）叫做一個類型形參。在 cs 的聲明中，String 的兩次使用都是類型實參（一次用於 Collection<V>，另一次用於 HashSet<V>）。
關
於何時可以使用類型形參，存在一些限制。大多數時候，可以在能夠使用實際類型定義的任何地方使用類型形參。但是有例外情況。不能使用它們創建對象或數組，
並且不能將它們用於靜態上下文中或者處理異常的上下文中。還不能將它們用作父類型（class Foo<T> extends
T），不能用於 instanceof 表達式中，不能用作類常量。
類似地，關於可以使用哪些類型作為類型實參，也存在一些限制。類型實參
必須是引用類型（不是基本類型）、通配符、類型參數，或者其他參數化類型的實例化。所以您可以定義
List<String>（引用類型）、List<?>（通配符）或者
List<List<?>>（其他參數化類型的實例化）。在帶有類型形參 T 的參數化類型的定義中，您也可以聲明
List<T>（類型形參）。
❸ java 如何獲取 泛型的 class
package com.leo.common;
public class Genericity<T> {
public static void main(String[] args) {
Genericity<String> test = new Genericity<>("test1");
System.out.println(test.getGenericityName());
Genericity<Double> test1 = new Genericity<>(new Double(123));
System.out.println(test1.getGenericityName());
}
private T data;
public Genericity(T data) {
this.data = data;
}
public T getData() {
return this.data;
}
public String getGenericityName() {
return data.getClass().getName();
}
}
❹ 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。果然很方便。
❺ java泛型T和class.getName一樣嗎
不一樣，第一個class.getName();是Class對象的一個方法，它會返回一個類名的字元串，而sql = "from"+T，這句話的語法不正確。
還有Class 是一個類，Class 類的實例表示正在運行的 Java 應用程序中的類和介面，而泛型T 也是一個類，但他本身不是Class對象
下面給出一個測試代碼：
package ysw;
import java.util.*;
class Food{}
public class Test<T>
{
public void s(T t){
String s = ""+t;//泛型T 將調用對象的toString()方法，返回該字元串由類名（對象是該類的一個實例）、at 標記符「@」和此對象哈希碼的無符號十六進製表示 System.out.println(s);
Class<T> cl = (Class<T>) t.getClass();//讓泛型賦給Class對象，
System.out.println(cl.getName());//調用Class的getName()方法，返回類名。
}
public static void main(String args[]){
Test<Food> tf = new Test<Food>();
tf.s(new Food());
}
}
////
output:
ysw.Food@1eb2c1b
ysw.Food
❻ java class<t> 泛型怎麼寫
E - Element (在集合中使用，因為集合中存放的是元素)
T - Type（Java 類）
K - Key（鍵）
V - Value（值）
N - Number（數值類型）
? - 表示不確定的java類型
舉例說明：
Set<T> 表示 集合里 是 T類的實例
List<E> 表示 集合里 是 E類的實例
List<?> 表示 集合里的對象類型不確定，未指定
List 同 List<?> 是一樣的。
泛型的作用：
1、用泛型：
Java代碼 收藏代碼
List<T> list=new ArrayList<T>();
T t=list.get(0);
2、不用泛型：
Java代碼 收藏代碼
List list=new ArrayList();
T t=(T)list.get(0);
❼ 在java中，使用泛型，比如說T,但是T.class就要報錯。我想獲取T的class對象怎樣獲取啊。
T.getClass()或者T.class都是非法的，因為T是泛型變數。
由於一個類的類型是什麼是在編譯期處理的，故不能在運行時直接在Base里得到T的實際類型。
有一種變通的實現方式：
import java.lang.reflect.Array;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
public class Generic extends Base<String> {
public static void main(String[] args) {
Generic c = new Generic();
System.out.println(c.array);
}
Object array ;
public Generic() {
array = Array.newInstance(getGenericType(0), 100);
}
}
class Base<T> {
public Class getGenericType(int index) {
Type genType = getClass().getGenericSuperclass();
if (!(genType instanceof ParameterizedType)) {
return Object.class;
}
Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
if (index >= params.length || index < 0) {
throw new RuntimeException("Index outof bounds");
}
if (!(params[index] instanceof Class)) {
return Object.class;
}
return (Class) params[index];
}
}
其中Base<T>是泛型類，在父類中聲明getGenericType，子類繼承具體的Base<String>，那麼在子類中就可以通過getGenericType(0)獲取到String的class.
❽ java中泛型的class怎麼獲取
import java.lang.reflect.ParameterizedType;
public class GT1 extends GT2<Integer>{
public static void main(String[] args) {
System.out.println(((ParameterizedType)new GT1().getClass().getGenericSuperclass()));
}
}
則輸出結果即為：
GT2<java.lang.Integer>
❾ java class類的泛型有什麼意義
拿容器類來說吧。如果沒有泛型，容器中對象都是默認Object類型，可能會將錯誤的類型放入容器中，取出的時候進行轉型也是對Object進行強轉。如果有錯會拋出RuntimeException。加入泛型之後，就可以在編譯期發現這種錯誤。
❿ java中如何得到泛型參數的class
泛型的目的就是為了避免強制類型轉換，所以直接取出來就是object的類型了。
public
class
classtest
{
public
static
void
main(string[]
args)
{
list
liststr
=
new
arraylist
();
liststr.add("aaa");
liststr.add("bbb");
system.out.println(liststr.get(0));
}
}
你想要的應該是這個吧，只要取出來就是你定義類型的object了，在這個例子中是string。如果你給它定義的是integer類型的泛型的話，取出來就是integer了。