java泛型獲取class

⑴ 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 的泛型中的對象類型

/**
*獲取field的類型，如果是復合對象，獲取的是泛型的類型
*
*@paramfield
*@return
*/
(Fieldfield){
ClassfieldClazz=field.getType();

if(fieldClazz.isAssignableFrom(List.class)){
Typefc=field.getGenericType();//關鍵的地方，如果是List類型，得到其Generic的類型

if(fcinstanceofParameterizedType)//如果是泛型參數的類型
{
ParameterizedTypept=(ParameterizedType)fc;

fieldClazz=(Class)pt.getActualTypeArguments()[0];//得到泛型里的class類型對象。
}
}

returnfieldClazz;
}

正好這幾天剛寫了相關代碼，供參考

⑶ Java中定義泛型<T>時，怎麼獲得泛型的類型

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泛型該怎麼深繼承 amp;怎麼獲得數組的class對象

泛型的類型是無法在運行時通過反射取得的，泛型類型在編譯成位元組碼的時候已經被虛擬機給去掉了，只是起到提示編譯器進行類型檢查的作用
用這種方法你試一試:父類:import java.lang.reflect.ParameterizedType;
public class Parent<T {
public Parent() {
ParameterizedType type = (ParameterizedType)this.getClass().getGenericSuperclass();
System.out.println("type==" + type);
System.out.println("entityClass==" + type.getActualTypeArguments()[0]);
System.out.println("getOwnerType==" + type.getOwnerType());
System.out.println("getRawType==" + type.getRawType());}}子類:public class Child<T extends Parent<String {

⑸ 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了。

⑹ JAVA 類名.class是什麼意思

ConfMgr.class是獲取ConfMgr的class對象，類型類指的是代表一個類型的類，因為一切皆是對象，幾種獲取class對象的方法：

1，所有的引用數據類型（類-類型）的類名、基本數據類型都可以通過.class方式獲取其 Class對象。

對於基本數據類型的封裝類還可以通過.TYPE 的方式獲取其 Class 對象，但要注意。TYPE 實際上獲取的封裝類對應的基本類型的 Class 對象的引用。

那麼你可以判斷出int.class==Integer.TYPE 返回 true，int.class==Integer.class 返回 false！通過這種方式不會初始化靜態域，使用.class、.TYPE 的方式獲取 Class對象叫做類的字面常量；

2，Class 的 forName(String name)傳入一個類的完整類路徑也可以獲得 Class 對象。

由於使用的是字元串，必須強制轉換才可以獲取泛型的Class<T>的 Class對象，並且必須獲取這個方法可能拋出的ClassNotFoundException異常。這種方法可以初始化靜態域。

3，還可通過類的對象實例下的getClass()方法來獲取Class對象，即 實例名getClass()

(6)java泛型獲取class擴展閱讀

在一個面向對象的系統中，類（class）是數據和操作數據的方法的集合。數據和方法一起描述對象（object）的狀態和行為。

每一對象是其狀態和行為的封裝。類是按一定體系和層次安排的，使得子類可以從超類繼承行為。在這個類層次體系中有一個根類，它是具有一般行為的類。

當編輯並運行一個Java程序時，需要同時涉及到這四種方面。使用文字編輯軟體（例如記事本、寫字板、UltraEdit等）或集成開發環境（Eclipse、MyEclipse等）在Java源文件中定義不同的類。

通過調用類（這些類實現了Java API）中的方法來訪問資源系統，把源文件編譯生成一種二進制中間碼，存儲在class文件中。

通過運行與操作系統平台環境相對應的Java虛擬機來運行class文件，執行編譯產生的位元組碼，調用class文件中實現的方法來滿足程序的Java API調用 。

⑺ java獲取泛型

這段代碼放在BaseDaoImpl中，在for循環中列印的t就是T和PK。

最後得到的persistType就是T的實際類型。

解釋一下紅色的部分：

因為this代表你的實例，

如果這個實例是（用Integer做ID的Student數據對象為例）

BaseDaoImpl<Student, Integer>studentDao=new BaseDaoImpl<Student, Integer>();

這個實例的「范型父類」(getGenericSuperclass)就是BaseDao<Student, Integer>，

如果你的實例是BaseDaoImpl<T, PK>子類的實例，

那麼「范型父類」就是BaseDaoImpl<T, PK>，

反正不是HibernateDaoSupport，因為HibernateDaoSupport不帶范型。

最後，不管是BaseDaoImpl，還是BaseDao，getActualTypeArguments()都得到Class數組，內容是｛T的類型，PK的類型｝，取第一個（下標0），就得到T的類型（例中為Student.class）。

⑻ 在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如何獲得泛型中的類

泛型的目的就是為了避免強制類型轉換，所以直接取出來就是Object的類型了。

public class ClassTest {
public static void main(String[] args) {
List<String> listStr = new ArrayList<String>();

listStr.add("AAA");
listStr.add("BBB");

System.out.println(listStr.get(0));
}
}

你想要的應該是這個吧，只要取出來就是你定義類型的Object了，在這個例子中是String。如果你給它定義的是Integer類型的泛型的話，取出來就是Integer了。