精华内容
下载资源
问答
  • //判断参数类型 if(xclass.equals("class java.lang.String")) { setMethod.invoke(tObject, cell.getStringCellValue()); } else if(xclass.equals("class java.util.Date")) { setMethod.invoke(tObject, sf....

    while (cellbody.hasNext()) {

    Cell cell = cellbody.next();

    // 这里得到此列的对应的标题

    String titleString = (String) titlemap.get(k);

    // 如果这一列的标题和类中的某一列的Annotation相同,那么则调用此类的的set方法,进行设值

    if (fieldmap.containsKey(titleString)) {

    Method setMethod = (Method) fieldmap.get(titleString);

    //得到setter方法的参数

    Type[] ts = setMethod.getGenericParameterTypes();

    //只要一个参数

    String xclass = ts[0].toString();

    //判断参数类型

    if(xclass.equals("class java.lang.String"))

    {

    setMethod.invoke(tObject, cell.getStringCellValue());

    }

    else if(xclass.equals("class java.util.Date"))

    {

    setMethod.invoke(tObject, sf.parse(cell.getStringCellValue()));

    }

    else if(xclass.equals("class java.lang.Boolean"))

    {

    Boolean boolname=true;

    if(cell.getStringCellValue().equals("否"))

    {

    boolname=false;

    }

    setMethod.invoke(tObject,boolname );

    }

    else if(xclass.equals("class java.lang.Integer"))

    {

    setMethod.invoke(tObject,new Integer( cell.getStringCellValue()));

    }

    else if(xclass.equals("class java.lang.Long"))

    {

    setMethod.invoke(tObject,new Long( cell.getStringCellValue()));

    }

    }

    // 下一列

    2011年8月01日 14:53

    展开全文
  • import java.lang.reflect.Constructor;import java.lang.reflect.Field;import java.lang.reflect.Method;//通过反射获取方法信息public class getMethodUtil {public static void main(String[] ar...

    package com.mysec.reflex;

    import java.lang.reflect.Constructor;

    import java.lang.reflect.Field;

    import java.lang.reflect.Method;

    //通过反射获取方法信息

    public class getMethodUtil {

    public static void main(String[] args) {

    String string = "hell";

    // printClassMethodMessage(string);

    //        printFieldMessage(string);

    printConMessage(string);

    }

    // public static void main(String[] args) {

    // Class> c1 = int.class;

    // Class> c2 = String.class;

    // Class> c3 = double.class;

    // Class> c4 = Double.class;

    // Class> c5 = void.class;

    // System.out.println(c1.getName());

    // System.out.println(c2.getName());

    // System.out.println(c2.getSimpleName());//不带包名的名称

    // }

    /**

    * 打印类的信息,包括类的成员函数、成员变量(只获取成员函数)

    *

    * @param object

    *            该对象所属类的信息

    */

    public static void printClassMethodMessage(Object object) {// 该类所属 的信息

    // 要获取类的信息,首先要获取类的类类型

    Class> class1 = object.getClass();// 传递的是哪个子类的对象,class1就是该子类的类类型

    // 获取类的名称

    System.out.println("类的名称是:" + class1.getName());

    /**

    * Method类,方法对象 一个成员方法就是一个Method对象 getMehtod()方法

    * 获取的是所有得public的函数,包括父类继承的 getDeclaredMethods()获取的是所有该类声明的方法,不同访问权限

    */

    Method[] ms = class1.getMethods();

    for (int i = 0; i < ms.length; i++) {

    // 得到方法的返回值类型的类类型

    Class> returnType = ms[i].getReturnType();

    System.out.print(returnType.getName() + " ");

    // 得到方法的名称

    System.out.print(ms[i].getName() + "(");

    // 获取参数类型

    Class[] paramTypes = ms[i].getParameterTypes();

    for (Class class2 : paramTypes) {

    System.out.print(class2.getName() + ",");

    }

    System.out.println(")");

    printFieldMessage(class1);

    }

    }

    /**

    * 获取成员变量信息

    *

    * @param object

    */

    private static void printFieldMessage(Object object) {

    // 要获取类的信息,首先要获取类的类类型

    Class> class1 = object.getClass();// 传递的是哪个子类的对象,class1就是该子类的类类型

    // 获取类的名称

    System.out.println("类的名称是:" + class1.getName());

    /**

    * 成员变量也是对象 java.lang.reflect.Field Field类封装了关于成员变量的操作

    * getFields()方法获取的是所有的public的成员变量的信息

    * getDeclaredFields获取的是该类自己声明的成员变量的信息

    */

    // Field[] fs = class1.getFields();

    Field[] fs = class1.getDeclaredFields();

    for (Field field : fs) {

    // 得到成员变量的类型的类类型

    Class> filedType = field.getType();

    String typeName = filedType.getName();

    String fieldName = field.getName();

    System.out.println(typeName + " " + fieldName);

    }

    }

    /**

    * 打印对象的构造函数的信息

    *

    * @param object

    */

    public static void printConMessage(Object object) {

    Class> class1 = object.getClass();

    /**

    * 构造函数也是对象 java.lang.Constructor中封装了构造函数的信息

    * getConstructors获取所有的public的构造函数 getDeclaredConstructors得到所有的构造函数

    */

    // Constructor[] cs = class1.getConstructors();

    Constructor[] cs = class1.getDeclaredConstructors();

    for (Constructor constructor : cs) {

    System.out.print(constructor.getName() + "(");

    // 获取构造函数的参数列表--->得到的是参数列表的类类型

    Class[] paramTypes = constructor.getParameterTypes();

    for (Class class2 : paramTypes) {

    System.out.print(class2.getName() + ",");

    }

    System.out.println(")");

    }

    }

    }

    展开全文
  • 但有几种特殊情况,能够获取泛型对象的参数类型:1、类中有 class 信息(类中有一个 Class 字段)2、父类中有 class 信息(父类是泛型类,并指定了参数类型)3、持有者中有 class 信息(是一个类的 Field、Method)一、类...

    由于类型擦除,java 中的泛型对象在运行时是不知道自己类型参数的类型的。

    但有几种特殊情况,能够获取泛型对象的参数类型:

    1、类中有 class 信息(类中有一个 Class 字段)

    2、父类中有 class 信息(父类是泛型类,并指定了参数类型)

    3、持有者中有 class 信息(是一个类的 Field、Method)

    一、类中有 class 信息

    类声明:

    static class A1{

    public Class mClass;

    public A1(Class aClass){

    mClass = aClass;

    }

    }

    复制代码

    使用:

    A1 a1 = new A1<>(String.class);

    System.out.println(a1.mClass);

    复制代码

    输出:

    class java.lang.String复制代码

    二、父类中有 class 信息

    2.1 子类

    类声明:

    static class A2 extends A2Parent{

    }

    static class A2Parent{

    }

    复制代码

    使用:

    A2 a2 = new A2();

    printClass(a2);

    public static void printClass(Object o){

    System.out.println();

    format("o: ", o);

    format("class: ", o.getClass());

    format("superClass: ", o.getClass().getSuperclass());

    format("genericSuperClass: ", o.getClass().getGenericSuperclass());

    format("genericSuperClass typeArgument: ", ((ParameterizedType) o.getClass().getGenericSuperclass()).getActualTypeArguments()[0]);

    }

    复制代码

    输出:

    o: A2@28a418fc

    class: class A2

    superClass: class A2Parent

    genericSuperClass: A2Parent

    genericSuperClass typeArgument: class java.lang.String

    复制代码

    2.2 匿名子类

    使用:

    A2Parent parent = new A2Parent() {

    };

    printClass(parent);

    复制代码

    输出:

    o: $1@5305068a

    class: $1

    superClass: A2Parent

    genericSuperClass: A2Parent

    genericSuperClass typeArgument: class java.lang.String

    复制代码

    三、持有者中有 class 信息

    类声明:

    static class A3{

    }

    static class A3User{

    A3 a3 = new A3<>();

    }

    复制代码

    使用:

    A3User a3User = new A3User();

    try {

    Field field = FieldUtils.getField(a3User.getClass(), "a3");

    System.out.println(((ParameterizedType) field.getGenericType()).getActualTypeArguments()[0]);

    } catch (Exception e) {

    e.printStackTrace();

    }

    复制代码

    输出:

    class java.lang.String复制代码

    展开全文
  • 获取未知类型对象的属性通常有两种方式:一是通过自定义注解的方式,通过获取被注解的属性从而获取属性的值,这种方式也是Spring参数注入的重要实现手段二是通过反射获取属性的名称,通过属性名从而获取属性,这种...

    获取未知类型对象的属性通常有两种方式:

    一是通过自定义注解的方式,通过获取被注解的属性从而获取属性的值,这种方式也是Spring参数注入的重要实现手段

    二是通过反射获取属性的名称,通过属性名从而获取属性,这种方式在开发时是比较简便易实现的。

    一、关于注解

    1、自定义注解

    首先定义一个@interface类型的注解接口

    @Target(ElementType.FIELD)

    @Retention(RetentionPolicy.RUNTIME)public @interfaceClassBeanId {

    }

    元注解的作用就是负责注解其他注解。

    1.@Target,

    2.@Retention,

    3.@Documented,

    4.@Inherited     这些类型和它们所支持的类在java.lang.annotation包中可以找到。下面我们看一下每个元注解的作用和相应分参数的使用说明。

    @Target说明了Annotation所修饰的对象范围:Annotation可被用于 packages、types(类、接口、枚举、Annotation类型)、类型成员(方法、构造方法、成员变量、枚举值)、方法参数和本地变量(如循环变量、catch参数)。在Annotation类型的声明中使用了target可更加明晰其修饰的目标。

    作用:用于描述注解的使用范围(即:被描述的注解可以用在什么地方)

    取值(ElementType)有:

    1.CONSTRUCTOR:用于描述构造器

    2.FIELD:用于描述域

    3.LOCAL_VARIABLE:用于描述局部变量

    4.METHOD:用于描述方法

    5.PACKAGE:用于描述包

    6.PARAMETER:用于描述参数

    7.TYPE:用于描述类、接口(包括注解类型) 或enum声明

    @Retention定义了该Annotation被保留的时间长短:某些Annotation仅出现在源代码中,而被编译器丢弃;而另一些却被编译在class文件中;编译在class文件中的Annotation可能会被虚拟机忽略,而另一些在class被装载时将被读取(请注意并不影响class的执行,因为Annotation与class在使用上是被分离的)。使用这个meta-Annotation可以对 Annotation的“生命周期”限制。

    作用:表示需要在什么级别保存该注释信息,用于描述注解的生命周期(即:被描述的注解在什么范围内有效)

    取值(RetentionPoicy)有:

    1.SOURCE:在源文件中有效(即源文件保留)

    2.CLASS:在class文件中有效(即class保留)

    3.RUNTIME:在运行时有效(即运行时保留)

    注:注解的的RetentionPolicy的属性值是RUTIME,这样注解处理器可以通过反射,获取到该注解的属性值,从而去做一些运行时的逻辑处理

    Annotation类型里面的参数该怎么设定:

    第一,只能用public或默认(default)这两个访问权修饰.例如,String value();这里把方法设为defaul默认类型;

    第二,参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型和 String,Enum,Class,annotations等数据类型,以及这一些类型的数组.例如,String value();这里的参数成员就为String;

    第三,如果只有一个参数成员,最好把参数名称设为"value",后加小括号。

    例如:

    示例1:

    自定义一个注解:

    @Target(ElementType.FIELD)

    @Retention(RetentionPolicy.RUNTIME)public @interfaceClassBeanId {public int id() default -1;

    }

    使用这个注解:

    public classClassBean {

    @ClassBeanId(id= 20) //使用已定义的注解默认值为20。如果需要赋值,就需要用反射将id的值取出来并赋给当前类的id

    private intid;public intgetId() {returnid;

    }public void setId(intid) {this.id =id;

    }

    @OverridepublicString toString() {return "ClassBean [id=" + id + "]";

    }

    }

    定义获取该注解下的属性

    public static void getData(T data) throwsIllegalArgumentException, IllegalAccessException{ int id = 0;

    Class clazz=data.getClass();

    Field[] fields=clazz.getDeclaredFields();for(Field field : fields){if(field.getAnnotation(ClassBeanId.class) != null){

    field.setAccessible(true);

    id=field.getInt(data);}

    System.out.println("id : "+id);

    }

    }

    将对象传入该方法中,通过反射判断该对象属性是否添加了注解,从而获取该对象的id属性。

    若要实现类似Spring框架中的参数注入,则需要重新定义一组方法,将注解中的参数传入对象之中,方法如下:

    public static void getDataFromAnnotation(T data) throwsIllegalArgumentException, IllegalAccessException{ int id = 0;

    Class clazz=data.getClass();

    Field[] fields=clazz.getDeclaredFields();for(Field field : fields){if(field.getAnnotation(ClassBeanId.class) != null){ //判断该属性是否被注解

    field.setAccessible(true);

    ClassBeanId classBeanId= field.getAnnotation(ClassBeanId.class); //实例该注解

    field.setInt(data, classBeanId.id()); //获取注解的值并赋值给传入对象}}

    }

    虽然并非严格的Spring框架的实现机制,但是原理是相同的。

    二、关于反射

    通过反射获取属性的名称,并对比属性命名就可以获取未知类型对象中某些属性值。这是一种比较常见的做法。

    public static void getDataField(T data) throwsIllegalArgumentException, IllegalAccessException{

    Class clazz=data.getClass();

    Field[] fields=clazz.getDeclaredFields();for(Field field : fields){

    String name=field.getName();if(name.equals("id")){

    field.setAccessible(true);

    field.setInt(data,29);

    }

    }

    }

    展开全文
  • import java.lang.reflect.ParameterizedType; public abstract class SampleObjectCallBack<T> { private Class<T> clazz; @SuppressWarnings("unchecked") public SampleObject...
  • 我想获取传入参数的Object 类型怎么做? 比如我使用objectToMap(List list1),怎么在objectToMap里面获取传入的类型是List或者其他的类型。这样我就能做一个判断将list也转成map使用。当然!能够获取到变量名list1就...
  • ParameterizedType获取java泛型参数类型 getClass().getGenericSuperclass()返回表示此 Class 所表示的实体(类、接口、基本类型或 void)的直接超类的 Type 然后将其转换ParameterizedType。。 ...
  • packagecom.wh.pj1.test...importjava.lang.annotation.ElementType;importjava.lang.annotation.Retention;importjava.lang.annotation.RetentionPolicy;importjava.lang.annotation.Target;importjava.lang.refle...
  • 获取java泛型参数类型

    2014-03-16 22:32:15
    //根据这个类的字节码,获得applyVector方法的mehtod对象 Method method=GenericTest.class.getMethod("applyVector", Vector.class); //获得一个参数类型扥对象 Type [] types=method.g
  • 需求是这样的:有一个类,类的路径知道,例如是com.xx.xx.xx其中有不同类型的成员变量(个数未知),有对应的setter和getter方法,有一个无参构造和一个全参构造。现在需要用反射机制...需求是这样的:有一个类,类的...
  • 本文接上文“老生常谈反射之Class类的使用(必看篇)”,以编写一个用来获取类的信息(成员函数、成员变量、构造函数)的工具类来讲解"反射之获取类的信息"1、获取成员函数信息/*** ...获取类的类类型Class c = obj.g...
  • Java 获取泛型对象的参数类型

    千次阅读 2020-03-01 13:48:28
    文章目录一、类中有 class 信息二...但有几种特殊情况,能够获取泛型对象的参数类型: 1、类中有 class 信息(类中有一个 Class 字段) 2、父类中有 class 信息(父类是泛型类,并指定了参数类型) 3、持有者中有 c...
  • 主要介绍了java获取网络类型的方法,涉及java针对网络类型参数获取及判定技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • Java获取泛型的类型参数

    千次阅读 2017-11-21 12:13:28
    在 Effective Java其他碎片建议3 这篇博客中,我们提到了泛型,也说了泛型的优点以及...那如何获取泛型的参数类型呢?下面看代码:package com.test; import java.lang.reflect.Field; import java.lang.reflect.Pa...
  • if(genericSuperclass instanceof ParameterizedType) { // 该泛型类的类型参数已经被参数化 } 如果类型参数已经被参数化,我们就可以通过调用下面的方法 package java.lang.reflect; public interface ...
  • public class Person {}import java.lang.reflect.ParameterizedType;import java.lang.reflect.Type;public class Student extends Person {public static void main(String[] args) {Student st=new Student();Cla...
  • java获取泛型类型

    2017-06-22 13:48:00
    java获取泛型类型 泛型是自java1.5以后引入的概念,主要为了弥补java语言强类型特性带来的编程上的不便。 泛型的本质是一种参数类型,对应的java中的类ParameterizedType.java所以,要获取运行时的...
  • Java反射,根据类名创建带参数的实例(获取参数类型,参数等)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,881
精华内容 1,152
关键字:

java获取参数类型

java 订阅