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