请教关于得到泛型的class

RyanPoy

浏览: 51219 次
性别:
来自: 长沙

最近访客更多访客>>

linwenbin

fuchaozi2050

leoeco2000

hubo.0508

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

core java

DAO Java C C++C#

在发帖之前，一直在考虑。该不该发。查了查我的问题。也没有找到一个解决方案。所以，还是来发帖了。就发在新手帖吧。也许真的只是一个新手的问题。

先描述一下问题。有这个一个类：

public class Test<T>
{
}

要得到T的class。
如果看到这，请继续看下文，千万不要给出一句：
[color=red]

Class<T> entityClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];

[/color]
的答复。因为，我已经试过了。

一直没有仔细研究泛型这个东西。所以直接上网查了。
基本上找到这样一个方法：

Class<T> entityClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];

于是，依葫芦画瓢：

public class Test<T>
{
	Class<T> clazz;

	public Test()
	{
		clazz = (Class<T>) ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
	}
	
	public static void main(String[] args)
	{
		Test<Integer> t = new Test<Integer>();
	}
}

执行后抛出异常如下：

Exception in thread "main" java.lang.ClassCastException: java.lang.Class cannot be cast to java.lang.reflect.ParameterizedType
	at Test.<init>(Test.java:9)
	at Test.main(Test.java:14)

查找原因。发现，java中的泛型采用擦拭法。无法得到自己本身的泛型。而调用getGenericSuperclass()方法得到的是父类的泛型。
所以，再次修改代码：

class Father<T>
{
	
}

public class Test<T> extends Father<T>
{
	Class<T> clazz;

	public Test()
	{
		clazz = (Class<T>) ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
		//((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments();
	}
	
	public static void main(String[] args)
	{
		Test<Integer> t = new Test<Integer>();
	}
}

运行后出现如下异常：

Exception in thread "main" java.lang.ClassCastException: sun.reflect.generics.reflectiveObjects.TypeVariableImpl cannot be cast to java.lang.Class
	at Test.<init>(Test.java:14)
	at Test.main(Test.java:20)

这下郁闷了。按道理说，这个是没有问题的。
于是我再次修改代码。把15行的注释打开，把14行注释掉。于是，代码如下：

class Father<T>
{
	
}

public class Test<T> extends Father<T>
{
	Class<T> clazz;

	public Test()
	{
		//clazz = (Class<T>) ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
		((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments();
	}
	
	public static void main(String[] args)
	{
		Test<Integer> t = new Test<Integer>();
	}
}

这次，没有抱任何异常。那么也就是说：getActualTypeArguments()[0] 无法强制转化成为Class<T>类型。乖乖，我本来就要得到这个类型。现在就差一步之遥了。

请问，我该如何得到了？

分享到：

hibernate入门使用系列 5 -- xml关系映射 ... | hibernate入门使用系列 4-- xml关系映射篇 ...

2008-07-14 18:13
浏览 14737
评论(9)
论坛回复 / 浏览 (6 / 7850)
分类:非技术
查看更多

9 楼 yaojianxiaoyu 2014-05-28

看你貌似不知道怎么弄，


public class BaseDao<T>  implements IBaseDao<T> {

	/**
	 * 通过反射获得传入的类
	 * @return
	 */
	public Class<T> getEntityClass() {
		Type type = getClass().getGenericSuperclass();
		ParameterizedType pType = (ParameterizedType)type;
		Type[] params = pType.getActualTypeArguments();
		@SuppressWarnings("unchecked")
		Class<T> c = (Class<T>)params[0];
		return c;
	}
//在具体的dao中继承过去
public class UserDao extends BaseDao<User> {

	public static void main(String[] args) {
		UserDao u = new UserDao();
		@SuppressWarnings("unused")
		Class<User> user = u.getEntityClass();
		System.out.println( u.getEntityClass().getName());
//org.tony.model.User
/***
*这个方式主要是用来获得具体实体类的，方便做操作，不用每个方法都传入class 了。
**/
	}

8 楼 d_xxm 2013-01-18

 
clazz = (Class<T>) ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];

抛出异常是因为没有在子类指定泛型类型。。。

public class Test1<T> extends Father<Integer> {。。。}

7 楼 jiajia11 2012-09-27

其实第二种方法我觉得不是泛型的应用，你把<T>去掉也是可以传进去参数的。
在DAO的应用中为了抽象出共同代码是应该有父类的，子类对应不同的DAO实现类。
所以第一种实现方法是对的。（个人理解）

6 楼 sigon 2008-12-24

也正在查这个问题,楼主这篇文章帮助很大,谢谢

5 楼 davidcen 2008-12-22

public abstract class BaseDAOImpl<T> extends JpaDaoSupport implements
IBaseDao<T> {

protected String className = "";

@SuppressWarnings("unchecked")
protected BaseDAOImpl() {
TypeVariable[] typeVariables = getClass().getTypeParameters();
if (typeVariables != null && typeVariables.length > 0) {
className = typeVariables[0].getName();
}
}
...
}

4 楼 dajianshi 2008-09-26

不是不行,只是有点Ugly

3 楼 RyanPoy 2008-07-18

总结。 对于解决方法1，要注意这样几点。 1). 只能取得父类的T.class，而且，要写一个子类，且子类在继承父类的时候，就要把类型给确定下来。即： 
<pre name='code' class='java'>public class Test extends Father<Integer>
{
}</pre>
 这样的话，其实Test在定义的时候就已经确定了类型了。 2). 这种方式不灵活，非得一个父类，一个子类。那么如果有一个Dao
<pre name='code' class='java'>public class Dao<T>
{
Class clazz;

public Dao()
{
clazz = (Class) ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
}
}</pre>
 如果要针对具体类型的时候，那么就得一个子类
<pre name='code' class='java'>public class UserDao extends Dao
{
}</pre>
 
同理，如果要操作多个对象，那么就有多个子类。这样，很冗余。 对于解决方式2， 1). 只需要一个类。而能解决所有的问题。
<pre name='code' class='java'>public class Test <T>
{
} </pre>
 2). 这个类需要一个带参数的构造。且这个参数就是泛型的class。也就是说，这个泛型的class是由外面传进去的。
<pre name='code' class='java'>public class Test <T>
{
Class clazz;

public Test(Class clazz)
{
this.clazz = clazz;
}
}</pre>
 3). 这种方式没有冗余。同样，以一个Dao来举例。
<pre name='code' class='java'>public class Dao<T>
{
Class clazz;

public Dao(Class clazz)
{
this.clazz = clazz;
}
}</pre>
 这样，如果有一个UserDao，我们只需要。
<pre name='code' class='java'>Dao userDao = new Dao(User.class); </pre>
 4). 这种方式对应于c++中的template更为接近。 
 
 c++中：
<pre name='code' class='cpp'>template <class T>
class Dao
{
public:
 Dao() {}
 ~Dao() {}
};

int main(int argc, char* argv[])
{
 Dao* dao = new Dao;
 delete dao;

 return 0;
} </pre>
 java中：
<pre name='code' class='java'>public class Dao<T>
{
Class clazz;

public Dao(Class clazz)
{
this.clazz = clazz;
}

public static void main(String[] args)
{
Dao dao = new Dao(User.class);
}
}</pre>
 两者唯一的区别在于。 1). c++代码中的构造方法可以不用参数，是一个默认构造就可以了。至于具体的是什么类型的参数。这个是在编译器编译成2进制文件时自动转化。 2). java代码中的构造方法，需要传递一个Class，这个Class就是T的Class。表面上看，好像这样子不合理。但是实际上想想，也没有不合理的地方。因为
<pre name='code' class='java'>Dao<User> dao = ...
</pre>
 
这个地方的时候，你就已经确定了是对User进行操作。那构造方法中传递一个User.Class，又有何不可呢？ 综上，采用2种方式中的任意一种都可以。不过，我更加喜欢第2种。

2 楼 RyanPoy 2008-07-18

解决方法2：

一个类就可以了。不过这个有点投机。

public class Test2<T>
{
	Class<T> clazz;

	@SuppressWarnings("unchecked")
	public Test2(Class<T> clazz)
	{
		this.clazz = clazz;
		System.out.println(clazz);
	}

	public static void main(String[] args)
	{
		Test2<Integer> t = new Test2<Integer>(Integer.class);
	}
}

1 楼 RyanPoy 2008-07-18

自己找到了解决方法。有2种方式。
1：
先有一个父类

public class Father<T>
{
	Class<T> clazz;

	@SuppressWarnings("unchecked")
	public Father()
	{
		clazz = (Class<T>) ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
	}
}

然后有一个子类：

public class Test1 extends Father<Integer>
{
	public Test1()
	{
		System.out.println(clazz);
	}

	public static void main(String[] args)
	{
		Test1 t = new Test1();
	}
}

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论