您好，登录后才能下订单哦！
密码登录
登录注册
点击 登录注册 即表示同意《亿速云用户服务条款》
本文小编为大家详细介绍“Java反射类型Type的使用方法有哪些”，内容详细，步骤清晰，细节处理妥当，希望这篇“Java反射类型Type的使用方法有哪些”文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧。
首先得到object的class对象
然后在class对象中用getDeclaredFields()方法来获得class的成员变量
FieldTest ft = new FieldTest();
Class ftClass = ft.getClass();
Field[] fields = ftClass.getDeclaredFields();Field对象有很多成员方法
getName()获取名称。
getGenericType() 返回一个Type对象
getType() 返回Class对象
getGenericType 和getType区别:
返回类型一个是Class对象一个是Type接口。
如果属性是泛型，getType（）返回属性的接口类型。getGenericType（）还能返回参数类型。
String fieldName = field.getName();
Type genericType = field.getGenericType();
boolean isParameterizedType = (genericType instanceof ParameterizedType);
Class fieldClazz = field.getType();
String valueTypeName = genericType.getTypeName();获取 范型的key和value的Type
Type[] genericTypes = ((ParameterizedType) genericType).getActualTypeArguments();
Type type0 = genericTypes[0];
Type type1 = genericTypes[1];通过google的com.google.common.reflect.TypeToken.of(type1).getRawType()方法获取map的key或者value的class类型。
Class<?> clazz = com.google.common.reflect.TypeToken.of(type1).getRawType();class FieldTest {
private String pri;
protected String pro;
public Map<Integer, HashMap<Integer, Float>> fcmap;
public FieldTest() {
}
public FieldTest(String pri, String pro, String pub) {
this.pri = pri;
this.pro = pro;
}
}package cn.hyperchain.hvm.abi;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
public class Test {
private static boolean checkClazzIsSpecific(Class CClazz, Class specific) {
if (CClazz == specific) return true;
Class[] interfaces = CClazz.getInterfaces();
boolean result = false;
for (Class inter : interfaces) {
if (result) break;
if (inter == specific) {
result = true;
break;
}
result = checkClazzIsSpecific(inter, specific);
}
return result;
}
public static void main(String args[]) {
FieldTest ft = new FieldTest();
Class ftClass = ft.getClass();
Field[] fields = ftClass.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
String fieldName = field.getName();
Type genericType = field.getGenericType();
Class fieldClass = field.getClass();
boolean isParameterizedType = (genericType instanceof ParameterizedType);
Class fieldClazz = field.getType();
String valueTypeName = genericType.getTypeName();
System.out.println();
System.out.println("-------------------------------------------------");
System.out.println();
System.out.println("fieldName: " + fieldName);
System.out.println("genericType: " + genericType);
System.out.println("fieldClazz: " + fieldClazz);
System.out.println("isParameterizedType: " + isParameterizedType);
System.out.println("valueTypeName: " + valueTypeName);
if (checkClazzIsSpecific(fieldClazz, Map.class)) {
Type[] genericTypes = ((ParameterizedType) genericType).getActualTypeArguments();
Type type0 = genericTypes[0];
Type type1 = genericTypes[1];
String type1Name = genericTypes[1].getTypeName();
System.out.println("type0: " + type0);
System.out.println("type1: " + type1);
System.out.println("type1Name: " + type1Name);
System.out.println(type1 instanceof ParameterizedType);
Type type3 = ((ParameterizedType)type1).getOwnerType();
Class type4 = type1.getClass();
//Class<?> type5 = (Class<?>) type1;
System.out.println("type3: " + type3);
System.out.println("type4: " + type4);
//System.out.println(type5);
Class<?> clazz = com.google.common.reflect.TypeToken.of(type1).getRawType();
System.out.println("clazz: " + clazz);
}
}
}
}
class FieldTest {
private String pri;
protected String pro;
// public Map<String, Integer> map;
public Map<Integer, HashMap<Integer, Float>> fcmap;
public FieldTest() {
}
public FieldTest(String pri, String pro, String pub) {
this.pri = pri;
this.pro = pro;
}
}
class abc {
private String pri;
protected String pro;
public String pub;
public String[] string;
public int[] innt;
public Map<String, Integer> map;
public abc() {
}
public abc(String pri, String pro, String pub) {
this.pri = pri;
this.pro = pro;
this.pub = pub;
}
}-------------------------------------------------
fieldName: pri
genericType: class java.lang.String
fieldClazz: class java.lang.String
isParameterizedType: false
valueTypeName: java.lang.String-------------------------------------------------
fieldName: pro
genericType: class java.lang.String
fieldClazz: class java.lang.String
isParameterizedType: false
valueTypeName: java.lang.String-------------------------------------------------
fieldName: fcmap
genericType: java.util.Map<java.lang.Integer, java.util.HashMap<java.lang.Integer, java.lang.Float>>
fieldClazz: interface java.util.Map
isParameterizedType: true
valueTypeName: java.util.Map<java.lang.Integer, java.util.HashMap<java.lang.Integer, java.lang.Float>>
type0: class java.lang.Integer
type1: java.util.HashMap<java.lang.Integer, java.lang.Float>
type1Name: java.util.HashMap<java.lang.Integer, java.lang.Float>
true
type3: null
type4: class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
clazz: class java.util.HashMapProcess finished with exit code 0
补充：Java-使用反射获取类型信息
最近写了大量需要根据类属性的类型反射注入值的代码，总结了以下常用的反射技巧：
在这个类中，有普通的String类型，有数组类型，有带泛型的List类型，有嵌套List类型，以及有多个泛型参数的简单类，这个类将作为我们后面的内容的基础。我们这一次博客解析如何使用反射获取到不同属性的类型值。
public class Some{
private String name;
private Integer[] numbers;
private List<String> list;
private List<List<Double>> matrix;
private Map<String,Class> map;
//ignore getter and setter
}普通类型的变量直接field.getType()即可以获取到他们的类型
public void queryNameType() throws NoSuchFieldException {
Field field = Some.class.getDeclaredField("name");
Class<?> type = field.getType();
assertEquals(type,String.class);
}数组类型不像其他的类型可以通过isAssignableFrom()函数来进行判断，他需要使用isArray() 来判断该type是否是一个数组类型，然后使用getComponentType() 获取他的元素的类型
public void queryArrayType() throws NoSuchFieldException {
Field field = Some.class.getDeclaredField("numbers");
Class<?> type = field.getType();
//一般来说，判断是否是某种类型是可以使用isAssignableFrom
// 判断是否是数组类型比较特殊，要使用isArray()这个函数
if (type.isArray()){
//获得数组的类型，使用getComponentType()这个方法
Class<?> componentType = type.getComponentType();
assertEquals(componentType,Integer.class);
}
else{
throw new IllegalStateException();
}
}带泛型的类型就是类似于List<String>这样的类型，我们现在的任务就是获取到String这个类型。
ParameterizedType表示参数化的类型，例如Collection这样的类型。我们可以通过getGenericType()方法获得该子类，当你的类型带有参数的时候就会返回ParameterizedType,否则会返回普通的类型(class)
那么具体是怎么操作的呢？
以获得List<T>的类型为例子
public void getListType() throws NoSuchFieldException {
Field field = Some.class.getDeclaredField("list");
//如果类似于List<String>这样的类型就是一种GenericType
//注意这是一种Type类型
Type type = field.getGenericType();
if (type instanceof ParameterizedType){
//泛型参数类型
ParameterizedType parameterizedType = (ParameterizedType)type;
Type[] actualTypes = parameterizedType.getActualTypeArguments();
//因为List<String>获得第一个泛型参数,因为只有一个，我们取第一个
//如果我们有多个泛型参数，我们可以根据顺序取不同的泛型参数
assertEquals(actualTypes[0],String.class);
//如果获得List这个原始类型呢？
assertEquals(parameterizedType.getRawType(),List.class);
}else{
throw new IllegalStateException();
}
}假如是List<List<String>> 如何获得最里面的类型呢？
例子如下
public void getSubListType() throws NoSuchFieldException {
//思考一下，如果我们有一个嵌套List，我们想拿到嵌套在最里面的类型，那么我们可以这么做呢？
//其实我们可以使用递归的思想去获得最里面的类型
Field field = Some.class.getDeclaredField("matrix");
assertEquals(getBaseType(field.getGenericType()),Double.class);
}
public static Type getBaseType(Type genericReturnType){
Objects.requireNonNull(genericReturnType);
if (genericReturnType instanceof ParameterizedType &&
List.class.isAssignableFrom((Class)(((ParameterizedType) genericReturnType).getRawType()))){
Type[] actualTypeArguments = ((ParameterizedType)genericReturnType).getActualTypeArguments();
Type type = actualTypeArguments[0];
return getBaseType(type);
}else{
return genericReturnType;
}
}与第三个例子相似，只需要使用actualTypes数组按顺序取即可
例子如下
public void getMapType() throws NoSuchFieldException {
Field field = Some.class.getDeclaredField("map");
Type type = field.getGenericType();
if (type instanceof ParameterizedType){
ParameterizedType parameterizedType = (ParameterizedType)type;
Type[] actualTypes = parameterizedType.getActualTypeArguments();
assertEquals(actualTypes[0],String.class);
assertEquals(actualTypes[1],Class.class);
}else{
throw new IllegalStateException();
}
}读到这里，这篇“Java反射类型Type的使用方法有哪些”文章已经介绍完毕，想要掌握这篇文章的知识点还需要大家自己动手实践使用过才能领会，如果想了解更多相关内容的文章，欢迎关注亿速云行业资讯频道。
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。