java获取泛型的类型
Ⅰ 如何获取 java 的泛型中的对象类型
classHuman{
publicStringtoString(){
return"Thisishuman";
}
}
classManextendsHuman{
publicStringtoString(){
return"Thisisman";
}
}
classWomanextendsHuman{
publicStringtoString(){
return"Thisiswoman";
}
}
publicclassGetObj{
/**
*获取泛型的对象类型
*
*@paramobj
*泛型对象
*/
publicstatic<T>voidshowInstance(Tobj){
try{
ObjecttmpObj=obj.getClass().newInstance();//实例化泛型对象
if(tmpObjinstanceofHuman){//Human的对象
System.out.println(tmpObj);
}elseif(tmpObjinstanceofMan){//Man的对象
System.out.println(tmpObj);
}else{//Woman的对象
System.out.println(tmpObj);
}
}catch(Exceptione){
e.printStackTrace();
}
}
publicstaticvoidmain(String[]args){
Humanh=newHuman();
showInstance(h);
Manm=newMan();
showInstance(m);
Womanw=newWoman();
showInstance(w);
}
}
Ⅱ java怎么获取一个泛型方法的真实泛型类型
不知道我对你的题目的理解对不对：有个方法返回一个 泛型 ，你想去这个 泛型 的类型是不是？
packagetest;
importjava.util.ArrayList;
importjava.util.List;
publicclassTest01{
publicstaticvoidmain(String[]args){
List<String>strings=newArrayList<String>();
strings.add("123");//模拟返回一个泛型
System.out.println(strings.getClass());//第一次取类型
System.out.println(strings.get(0).getClass());//假如通过第一步知道是ArrayList类型，则再取类型
}
}
输出结果：
class java.util.ArrayList
class java.lang.String
这里只举例讲一下方法，不知道是不是你想要的，
Ⅲ 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中定义泛型<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中如何得到泛型参数的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 怎么获取list泛型里的对象类型
获取java泛型中的对象类型，可以参考如下代码： /*** 通过反射取到 List 中 T 的类型* @param clazz* @param field* @return*/public static Class
Ⅶ 如何获取 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泛型的参数类型
一般可以使用反射来获取泛型参数的实际类型，以下是详细代码：
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Map;
public class GenericTest {
/*使用反射来获取泛型信息*/
private Map<String, Integer> score;
public static void main(String[] args) throws SecurityException, NoSuchFieldException {
//Class clazz = GenericTest.class;
Class<GenericTest> clazz = GenericTest.class;
//System.out.println(clazz);
Field f = clazz.getDeclaredField("score");
//直接使用getType只对普通类型有效，无法取到泛型参数
Class<?> a = f.getType();
System.out.println("score的类型是："+a);
//获得Field实例f的泛型类型
Type gType = f.getGenericType();
//如果gType类型是ParameterizedType的对象
if (gType instanceof ParameterizedType) {
ParameterizedType pType = (ParameterizedType) gType;
//获取原始类型
Type rType = pType.getRawType();
System.out.println("原始类型是："+rType);
//取得泛型类型参数
Type[] tArgs = pType.getActualTypeArguments();
System.out.println("泛型类型是：");
for (int i = 0; i < tArgs.length; i++) {
System.out.println("第"+i+"个泛型类型是："+tArgs[i]);
}
}else{
System.out.println("获取泛型类型出错！");
}
}
}
输出结果如下：
score的类型是：interface java.util.Map
原始类型是：interface java.util.Map
泛型类型是：
第0个泛型类型是：class java.lang.String
第1个泛型类型是：class java.lang.Integer