精华内容
下载资源
问答
  • Java反射使用

    千次阅读 2018-04-21 12:31:33
    这种动态获取类的信息以及动态调用对象的方法的功能来自于Java语言习得反射(Reflection)机制。 一般而言,当用户使用一个类的时候,应该先知道这个类,然后实例化对象;反射是通过对象找到类。 二、获得Class...

    一、反射介绍

    在Java运行时环境中,对于任意一个类,可以知道这个类有哪些属性和方法。对于任意一个对象,可以调用它的任意一个方法。这种动态获取类的信息以及动态调用对象的方法的功能来自于Java语言习得反射(Reflection)机制。

    一般而言,当用户使用一个类的时候,应该先知道这个类,然后实例化对象;反射是通过对象找到类。

    二、获得Class对象

    定义Demo类:

    package com.example;
    
    public class Demo {
    
        private Integer id;
    
        private String name;
    
    //    无参构造器
        public Demo() {
        }
    //     有参构造器
        public Demo(String name) {
            this.name = name;
        }
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }

    获得Class对象:

    //调用Class的静态方法:forname(String classPath)
    Class clazz = Class.forName("com.example.Demo");
    //调用运行时类的属性:.class
    Class clazz = Demo.class;
    //通过运行时类的对象,调用getClass()
    Class clazz = new Demo().getClass();
    //使用类的加载器:ClassLoader
    ClassLoader classLoader = Demo.class.getClassLoader();
    Class clazz = classLoader.loadClass("com.example.Demo");

    三、创建实例

    (1)无参构造器创建对象

    //获取Class对象
    Class clazz = Demo.class;
    //获取无参构造器
    Constructor constructor = clazz.getConstructor();
    //创建实例
    Object obj = constructor.newInstance();

    (2)有参构造器创建对象

    //获取Class对象
    Class clazz = Demo.class;
    //获取有参构造器
    Constructor constructor = clazz.getConstructor(String.class);
    //创建实例
    Object obj = constructor.newInstance("张三");

    四、获取成员变量

    getFields:获得公有(public)的成员变量

    getDeclareFields:获得某个类所有已声明(public、private、protected)的成员变量,不包括父类的成员变量

    package com.example;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    
    public class MyMain {
        public static void main(String[] args) {
            Class clazz = Demo.class;
    
            System.out.println("- - - getFields获取的成员变量 - - -");
            Field[] fs = clazz.getFields();
            for(Field f : fs){
                System.out.println(f);
            }
    
            System.out.println("- - - getDeclaredFields获取的成员变量 - - -");
            Field[] dfs = clazz.getDeclaredFields();
            for(Field f : dfs){
                System.out.println(f);
            }
    
        }
    }

    运行结果:

    - - - getFields获取的成员变量 - - -
    - - - getDeclaredFields获取的成员变量 - - -
    private java.lang.Integer com.example.Demo.id
    private java.lang.String com.example.Demo.name

     

    五、获取方法

     

    getMethods:获得所有公用(public)的方法,包括父类的公共方法

    getDeclaredMethods:获得某个类已声明(public、private、protected)的所有方法,不包括父类

    package com.example;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    
    public class MyMain {
        public static void main(String[] args) {
            Class clazz = Demo.class;
    
            System.out.println("- - - getMethods获取的方法 - - -");
            Method[] ms = clazz.getMethods();
            for(Method m : ms){
                System.out.println(m);
            }
    
            System.out.println("- - - getDeclaredMethods获取的方法 - - -");
            Method[] dms = clazz.getDeclaredMethods();
            for(Method m : dms){
                System.out.println(m);
            }
    
        }
    }
    

    运行结果:

    - - - getMethods获取的方法 - - -
    public java.lang.String com.example.Demo.getName()
    public java.lang.Integer com.example.Demo.getId()
    public void com.example.Demo.setName(java.lang.String)
    public void com.example.Demo.setId(java.lang.Integer)
    public final void java.lang.Object.wait() throws java.lang.InterruptedException
    public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
    public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
    public boolean java.lang.Object.equals(java.lang.Object)
    public java.lang.String java.lang.Object.toString()
    public native int java.lang.Object.hashCode()
    public final native java.lang.Class java.lang.Object.getClass()
    public final native void java.lang.Object.notify()
    public final native void java.lang.Object.notifyAll()
    - - - getDeclaredMethods获取的方法 - - -
    public java.lang.String com.example.Demo.getName()
    public java.lang.Integer com.example.Demo.getId()
    public void com.example.Demo.setName(java.lang.String)
    public void com.example.Demo.setId(java.lang.Integer)

    六、调用成员变量及方法

    用invoke()调用方法

    package com.example;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    
    public class MyMain {
        public static void main(String[] args) {
            Class clazz = Demo.class;
    
            System.out.println("- - - 设置和获取成员值 - - -");
            try {
                Constructor constructor = clazz.getConstructor();
                Object obj = constructor.newInstance();
                Field nameF = clazz.getDeclaredField("name");
                nameF.setAccessible(true);
    //           name成员赋值
                nameF.set(obj,"张三");
    //            得到name值
                System.out.println(nameF.get(obj));
            }catch (Exception ex){
                ex.printStackTrace();
            }
    
            System.out.println("- - - 调用方法 - - -");
            try {
                Constructor constructor = clazz.getConstructor();
                Object obj = constructor.newInstance();
    //            设置值
                Method nameS = clazz.getDeclaredMethod("setName", String.class);
                nameS.invoke(obj,"李四");
    //            获取值
                Method nameG = clazz.getDeclaredMethod("getName");
                Object t = nameG.invoke(obj);
                System.out.println(t);
            }catch (Exception ex){
                ex.printStackTrace();
            }
    
        }
    }
    

    运行结果:

    - - - 设置和获取成员值 - - -
    张三
    - - - 调用方法 - - -
    李四

     

    展开全文
  • JAVA反射使用手记

    万次阅读 2008-07-27 11:45:00
    JAVA反射使用手记 本篇文章为在工作中使用JAVA反射的经验总结,也可以说是一些小技巧,以后学会新的小技巧,会不断更新。本文不准备讨论JAVA反射的机制,网上有很多,大家随便google一下就可以了。 在开始之前,我...

     JAVA反射使用手

            本篇文章为在工作中使用JAVA反射的经验总结,也可以说是一些小技巧,以后学会新的小技巧,会不断更新。本文不准备讨论JAVA反射的机制,网上有很多,大家随便google一下就可以了。

            在开始之前,我先定义一个测试类Student,代码如下:

    package chb.test.reflect;
    
    public class Student {
    	private int age;
    	private String name;
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	
    	public static void hi(int age,String name){
    		System.out.println("大家好,我叫"+name+",今年"+age+"岁");
    	}
    }

    一、JAVA反射的常规使用步骤

        反射调用一般分为3个步骤:

    • 得到要调用类的class
    • 得到要调用的类中的方法(Method)
    • 方法调用(invoke)

         代码示例:

    Class cls = Class.forName("chb.test.reflect.Student");
    Method m = cls.getDeclaredMethod("hi",new Class[]{int.class,String.class});
    m.invoke(cls.newInstance(),20,"chb");

    二、方法调用中的参数类型

            在方法调用中,参数类型必须正确,这里需要注意的是不能使用包装类替换基本类型,比如不能使用Integer.class代替int.class。

           如我要调用Student的setAge方法,下面的调用是正确的:

     

    Class cls = Class.forName("chb.test.reflect.Student");
    Method setMethod = cls.getDeclaredMethod("setAge",int.class);
    setMethod.invoke(cls.newInstance(), 15);

     

           而如果我们用Integer.class替代int.class就会出错,如:

    Class cls = Class.forName("chb.test.reflect.Student");
    Method setMethod = cls.getDeclaredMethod("setAge",Integer.class);
    setMethod.invoke(cls.newInstance(), 15);

     

           jvm会报出如下异常:

    java.lang.NoSuchMethodException: chb.test.reflect.Student.setAge(java.lang.Integer)
    	at java.lang.Class.getDeclaredMethod(Unknown Source)
    	at chb.test.reflect.TestClass.testReflect(TestClass.java:23)

     

    三、static方法的反射调用

     

           static方法调用时,不必得到对象示例,如下:

    Class cls = Class.forName("chb.test.reflect.Student");
    Method staticMethod = cls.getDeclaredMethod("hi",int.class,String.class);
    staticMethod.invoke(cls,20,"chb");//这里不需要newInstance
    //staticMethod.invoke(cls.newInstance(),20,"chb");

    四、private的成员变量赋值

        如果直接通过反射给类的private成员变量赋值,是不允许的,这时我们可以通过setAccessible方法解决。代码示例:

    Class cls = Class.forName("chb.test.reflect.Student");
    Object student = cls.newInstance();//得到一个实例
    Field field = cls.getDeclaredField("age");
    field.set(student, 10);
    System.out.println(field.get(student));

     

         运行如上代码,系统会报出如下异常:

    java.lang.IllegalAccessException: Class chb.test.reflect.TestClass can not access a member of class chb.test.reflect.Student with modifiers "private"
    	at sun.reflect.Reflection.ensureMemberAccess(Unknown Source)
    	at java.lang.reflect.Field.doSecurityCheck(Unknown Source)
    	at java.lang.reflect.Field.getFieldAccessor(Unknown Source)
    	at java.lang.reflect.Field.set(Unknown Source)
    	at chb.test.reflect.TestClass.testReflect(TestClass.java:20)

        解决方法:

    Class cls = Class.forName("chb.test.reflect.Student");
    Object student = cls.newInstance();
    Field field = cls.getDeclaredField("age");
    field.setAccessible(true);//设置允许访问
    field.set(student, 10);
    System.out.println(field.get(student));

        其实,在某些场合下(类中有get,set方法),可以先反射调用set方法,再反射调用get方法达到如上效果,代码示例:

    Class cls = Class.forName("chb.test.reflect.Student");
    Object student = cls.newInstance();
    
    Method setMethod = cls.getDeclaredMethod("setAge",Integer.class);
    setMethod.invoke(student, 15);//调用set方法
    			
    Method getMethod = cls.getDeclaredMethod("getAge");
    System.out.println(getMethod.invoke(student));//再调用get方法
    展开全文
  • java 反射使用 Class.getMethod 应注意

    千次阅读 2018-07-12 23:19:28
    java 反射使用 Class.getMethod 应注意 记录下 Method method= clazz.getMethod(setMethodName,propertiesClass); 如果使用该方法 会不能获取以多态方式传入的参数 会抛异常 java.lang.NoSuchMethodException比如: ...

    java 反射使用 Class.getMethod 应注意 记录下

    Method method= clazz.getMethod(setMethodName,propertiesClass);
    如果使用该方法 会不能获取以多态方式传入的参数
    会抛异常 java.lang.NoSuchMethodException
    比如:

    public class Student {

    private String name;
    
    private int age;
    
    private List list = new ArrayList();
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    public List<Object> getList() {
        return list;
    }
    
    public void setList(List<Object> list) {
        this.list = list;
    }

    }

     public static void main(String[] args) {
        try {
            Class<?> clazz= Class.forName(Student.class.getTypeName());
            List list = new ArrayList();
            clazz.getMethod("setList",list.getClass());
    
        } catch (ClassNotFoundException | NoSuchMethodException e) {
            e.printStackTrace();
        }
    
    }
    
        此时会抛异常:
        java.lang.NoSuchMethodException: com.jcb.xml.model.Student.setList(java.util.ArrayList)
    
        解决方案:
    
        /**
     * 获取只有一个参数的对应方法
     * @param className
     * @param methodName
     * @return
     */
    private Method getMethod(String className,String methodName,Class<?> propertiesClass){
    
        Method[] methods=getMethods(className);
        for (Method method : methods) {
            if(method.getName().equals(methodName)){
                if(method.getParameterCount() == 1){
                    //该函数的参数类型和传入参数类型相同
                    if(method.getParameterTypes()[0].getTypeName().equals(propertiesClass.getTypeName())){
                        return method;
                        //该函数的参数类型是传入参数类型的父类
                    }else if(method.getParameterTypes()[0].getTypeName().equals(propertiesClass.getSuperclass().getTypeName())){
                        return method;
                    }else
                    {
                        Set<String> superClassAndSuperInterfaceList= this.getAllSuperClassAndSuperInterface(propertiesClass);
                        //如果传入参数类型是参数类型的子类 也返回改函数
                        if(superClassAndSuperInterfaceList.contains(method.getParameterTypes()[0].getTypeName()))
                            return method;
    
                    }
                }
            }
        }
        return  null;
    }
    
        /**
     * 获取所有父类类型和父类接口类型
     * @param clazz
     * @return
     */
    private Set<String> getAllSuperClassAndSuperInterface(Class<?> clazz){
        Set<String> superClassAndSuperInterfaceList = new HashSet<>();
        getAllSupersClasss(superClassAndSuperInterfaceList,clazz);
        getAllSuperInterfaces(superClassAndSuperInterfaceList,clazz);
        return superClassAndSuperInterfaceList;
    }
    
    /**
     * 递归获取所父类 类型
     * @param parentClassList
     * @param clazz
     */
    private Set<String> getAllSupersClasss(Set<String> parentClassList,Class<?> clazz){
        parentClassList.add(clazz.getSuperclass().getName());
        if(Object.class.getTypeName()!=clazz.getSuperclass().getTypeName()){
            //父类也可能实现接口
            getAllSuperInterfaces(parentClassList,clazz.getSuperclass());
            //递归查询父类
            getAllSupersClasss(parentClassList,clazz.getSuperclass());
        }
        return parentClassList;
    }
    
    /**
     * 递归获取父类接口
     * @param parentInterfaceList
     * @param clazz
     */
    private Set<String> getAllSuperInterfaces(Set<String> parentInterfaceList,Class<?> clazz){
        for (Class<?> aClass : clazz.getInterfaces()) {
            parentInterfaceList.add(aClass.getTypeName());
            //递归查询实现接口
            getAllSuperInterfaces(parentInterfaceList,aClass);
        }
        return parentInterfaceList;
    }
    
        使用该getMethod 代替反射 Class.getMethod 方法 就可以  
    
        多参数函数类似

    第二种方法 更清晰 包含多参数函数
    /**

    • 获取参数所对应的函数
    • @param className
    • @param argsClass
    • @return
      */
      private Method getMethod(String className, String methodName,Class<?>[] argsClass){
      Method[] methods=getMethods(className);
      for (Method method : methods) {
      if(method.getName().equals(methodName)) {
      if (method.getParameterTypes().length == argsClass.length) {
      if (checkArgsType(method.getParameterTypes(), argsClass)) {
      return method;
      }
      } else {
      continue;
      }
      }
      }

      return null;

      }

      /**

    • @param sourceArgsClass 函数的参数类型
    • @param argsClass 传入函数的参数类型
    • @return
      */
      private boolean checkArgsType(Class<?>[] sourceArgsClass,Class<?>[] argsClass){

      for (int i =0;i< sourceArgsClass.length;i++) {
          //aClass.isAssignableFrom(bClass)  判断a是否是b的父类或则父接口
          if(!sourceArgsClass[i].isAssignableFrom(argsClass[i]))
              return false;
      
      }
      
      return true;

      }

    转载于:https://blog.51cto.com/5013162/2141201

    展开全文
  • Java反射技术详解

    万次阅读 多人点赞 2019-04-14 23:11:32
    相信很多人都知道反射可以说是Java中最强大的技术了,它可以做的事情太多太多,很多优秀的开源框架都是通过反射完成的,比如最初的很多注解框架,后来因为java反射影响性能,所以被运行时注解APT替代了,java反射有...

    前言

      相信很多人都知道反射可以说是Java中最强大的技术了,它可以做的事情太多太多,很多优秀的开源框架都是通过反射完成的,比如最初的很多注解框架,后来因为java反射影响性能,所以被运行时注解APT替代了,java反射有个开源框架jOOR相信很多人都用过,不过我们还是要学习反射的基础语法,这样才能自己写出优秀的框架,当然这里所讲的反射技术,是学习Android插件化技术、Hook技术等必不可少的!

    一、基本反射技术

          1.1 根据一个字符串得到一个类

            getClass方法

     String name = "Huanglinqing";
     Class c1 = name.getClass();
     System.out.println(c1.getName());
    

         打印结果如下:

        

        Class.forName

        比如我们获取java.lang.String的类名 

       String name = "java.lang.String";
       Class c1 = null;
       try {
              c1 = Class.forName(name);
              System.out.println(c1.getName());
          } catch (ClassNotFoundException e) {
      }
    

        这里也通过捕获异常,因为我们传的这个字符串可能不合法,字符串合法命名是类的命名空间和类的名称组成

        打印结果如下:

        
       我们还可以通过c1.getSuperclass()获取到他的父类

       Type属性

        基本类型都有type属性,可以得到这个基本类型的类型,比如:

    Class c1 = Boolean.TYPE;
    Class c2 = Byte.TYPE;
    Class c3 = Float.TYPE;
    Class c4 = Double.TYPE;
    
     停停停!这些东西有啥子用,如此鸡肋! 别急,一切都是为后续做准备。

    二、获取类的成员

             当类中方法定义为私有的时候我们能调用?不能!当变量是私有的时候我们能获取吗?不能!但是反射可以,比如源码中有你需要用到的方法,但是那个方法是私有的,这个时候你就可以通过反射去执行这个私有方法,并且获取私有变量。

           获取类的构造函数

           为了便于测试,我们定义一个Test类,Test类如下:(省略get和set方法)

           Test类中我们定义是三个私有变量,生成两个公有的含参构造方法和一个私有的含参构造方法以及一个公有的无参构造方法。

    public class Test {
    
        private int age;
        private String name;
        private int testint;
    
        public Test(int age) {
            this.age = age;
        }
    
        public Test(int age, String name) {
            this.age = age;
            this.name = name;
        }
    
        private Test(String name) {
            this.name = name;
        }
    
        public Test() {
        }
    

          下面我们通过反射获取这些构造方法

           获取类的所有构造方法

     Test test = new Test();
     Class c4 = test.getClass();
     Constructor[] constructors ;
     constructors = c4.getDeclaredConstructors();
    

          通过getDeclaredConstructors可以返回类的所有构造方法,返回的是一个数组因为构造方法可能不止一个,通过getModifiers可以得到构造方法的类型,getParameterTypes可以得到构造方法的所有参数,返回的是一个Class数组,所以我们如果想获取所有构造方法以及每个构造方法的参数类型,可以有如下代码:

      for (int i = 0; i < constructors.length; i++) {
            System.out.print(Modifier.toString(constructors[i].getModifiers()) + "参数:");
            Class[] parametertypes = constructors[i].getParameterTypes();
            for (int j = 0; j < parametertypes.length; j++) {
                 System.out.print(parametertypes[j].getName() + " ");
           }
          System.out.println("");
      }
    

        运行结果如下所示:

        

        这样我们就得到了类中所有构造方法和构造方法中的参数,那么我们如何获取特定的构造方法呢?

        获取类中特定的构造方法

        我们可以通过getConstructors方法获取类中 所有的public类型的构造方法,代码和上面一样就不演示了。

        我们可以通过getDeclaredConstructor()方法传参获取特定参数类型的构造方法,这里注意是getDeclaredConstructor()不是  getDeclaredConstructors() ,所以返回的是一个Class对象而不是一个Class数组。

        获取无参构造方法直接不传参数,如下所示:

       try {
              constructors = c4.getDeclaredConstructor();
              System.out.print(Modifier.toString(constructors.getModifiers()) + );
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
          }
    

        这里要进行异常捕获,因为可能不存在对应的构造方法,打印结果如下:  

        

       如果我们想获取有两个参数分别为int和String类型的构造方法,代码如下:

      Class[] p = {int.class,String.class};
      try {
           constructors = c4.getDeclaredConstructor(p);
           System.out.print(Modifier.toString(constructors.getModifiers()) + "参数:");
           Class[] parametertypes = constructors.getParameterTypes();
           for (int j = 0; j < parametertypes.length; j++) {
                System.out.print(parametertypes[j].getName() + " ");
              }
           } catch (NoSuchMethodException e) {
                e.printStackTrace();
         }
    

      这里我们同样打印出构造方法的参数:


      

      调用构造方法

       从这里开始慢慢到了关键的一步,得到类的实例,我们主要借助于newInstance方法,为了方便演示我们将测试类的两个构造方法打印出来. 

       public Test(int age, String name) {
            this.age = age;
            this.name = name;
            System.out.println("hello" + name + "i am" + age);
        }
    
    
        private Test(String name) {
            this.name = name;
            System.out.println("My Name is" +
                    name);
        }
    

       我们先来调用public的方法,如下所示:

     Class[] p = {int.class,String.class};
     constructors = c4.getDeclaredConstructor(p);
     constructors.newInstance(24,"HuangLinqing");
    

     运行打印结果如下:


      

     那么调用私有构造方法呢,和上面一样,只是我们要设置constructors.setAccessible(true);代码如下:

      Class[] p = {String.class};
      constructors = c4.getDeclaredConstructor(p);
      constructors.setAccessible(true);
      constructors.newInstance("HuangLinqing");
    

      打印结果如下:


       

    调用类的私有方法

      如何调用类中的私有方法呢,我们先在测试类中编写一个测试的私有方法 如下:

      private void welcome(String tips){
            System.out.println(tips);
        }
    

      我们知道如果我们要正常的调用类的方法都是通过类.方法调用,所以我们调用私有方法也需要得到类的实例,而我们上面newInstace已经得到了类的实例,这样就好办了。

       Class[] p4 = {String.class};
       Method method = c4.getDeclaredMethod("welcome",p4);
       method.setAccessible(true);
    

       我们首先通过 getDeclaredMethod方法获取到这个私有方法,第一个参数是方法名,第二个参数是参数类型

       然后通过invoke方法执行,invoke需要两个参数一个是类的实例,一个是方法参数。

         Class[] p4 = {String.class};
         Method method = c4.getDeclaredMethod("welcome",p4);
         method.setAccessible(true);
         Object arg1s[] = {"欢迎关注代码男人技术公众号"};
         method.invoke(test,arg1s);
    

         test类的实例当不能new 获取的时候我们也可以通过反射获取,就是上面的newInstance方法。打印结果如下:


        

     获取类的私有字段并修改值

      看到这里你可能会说,有了set方法,什么私有不私有,test.set不就可以了,但是这里要注意我们是没有办法得到这个类的实例的,要不然都可以得到实例就没有反射一说了。我们在通过反射得到类的实例之后先获取字段:

    Field field = c4.getDeclaredField("name");
    field.setAccessible(true);
    field.set(o,"代码男人");
    

       o是我们上面通过反射构造方法获取的实例,  打印field.get(o).toString()的值如下:
      

       

       不过要注意的是我们修改了name的值只对当前的实例对象有效。

       Java的基本反射语法就是这样了,欢迎加入技术群一起探讨!

      最后反射封装类如下:

    package jnidemo.hlq.com.hookdemo;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    
    /**
     * @author Huanglinqing
     * @date 2019/4/28
     */
    
    public class Reflex {
    
        /**
         * 获取无参构造函数
         * @param className
         * @return
         */
        public static Object createObject(String className) {
            Class[] pareTyples = new Class[]{};
            Object[] pareVaules = new Object[]{};
    
            try {
                Class r = Class.forName(className);
                return createObject(r, pareTyples, pareVaules);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
    
            return null;
        }
    
        /**
         * 获取无参构造方法
         * @param clazz
         * @return
         */
        public static Object createObject(Class clazz) {
            Class[] pareTyple = new Class[]{};
            Object[] pareVaules = new Object[]{};
    
            return createObject(clazz, pareTyple, pareVaules);
        }
    
        /**
         * 获取一个参数的构造函数  已知className
         *
         * @param className
         * @param pareTyple
         * @param pareVaule
         * @return
         */
        public static Object createObject(String className, Class pareTyple, Object pareVaule) {
    
            Class[] pareTyples = new Class[]{pareTyple};
            Object[] pareVaules = new Object[]{pareVaule};
    
            try {
                Class r = Class.forName(className);
                return createObject(r, pareTyples, pareVaules);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
    
            return null;
        }
    
    
        /**
         * 获取单个参数的构造方法 已知类
         *
         * @param clazz
         * @param pareTyple
         * @param pareVaule
         * @return
         */
        public static Object createObject(Class clazz, Class pareTyple, Object pareVaule) {
            Class[] pareTyples = new Class[]{pareTyple};
            Object[] pareVaules = new Object[]{pareVaule};
    
            return createObject(clazz, pareTyples, pareVaules);
        }
    
        /**
         * 获取多个参数的构造方法 已知className
         * @param className
         * @param pareTyples
         * @param pareVaules
         * @return
         */
        public static Object createObject(String className, Class[] pareTyples, Object[] pareVaules) {
            try {
                Class r = Class.forName(className);
                return createObject(r, pareTyples, pareVaules);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
    
            return null;
        }
    
    
        /**
         * 获取构造方法
         *
         * @param clazz
         * @param pareTyples
         * @param pareVaules
         * @return
         */
        public static Object createObject(Class clazz, Class[] pareTyples, Object[] pareVaules) {
            try {
                Constructor ctor = clazz.getDeclaredConstructor(pareTyples);
                ctor.setAccessible(true);
                return ctor.newInstance(pareVaules);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            return null;
        }
    
    
        /**
         * 获取多个参数的方法
         * @param obj
         * @param methodName
         * @param pareTyples
         * @param pareVaules
         * @return
         */
        public static Object invokeInstanceMethod(Object obj, String methodName, Class[] pareTyples, Object[] pareVaules) {
            if (obj == null) {
                return null;
            }
    
            try {
                //调用一个private方法 //在指定类中获取指定的方法
                Method method = obj.getClass().getDeclaredMethod(methodName, pareTyples);
                method.setAccessible(true);
                return method.invoke(obj, pareVaules);
    
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            return null;
        }
    
        /**
         * 获取一个参数的方法
         * @param obj
         * @param methodName
         * @param pareTyple
         * @param pareVaule
         * @return
         */
        public static Object invokeInstanceMethod(Object obj, String methodName, Class pareTyple, Object pareVaule) {
            Class[] pareTyples = {pareTyple};
            Object[] pareVaules = {pareVaule};
    
            return invokeInstanceMethod(obj, methodName, pareTyples, pareVaules);
        }
    
        /**
         * 获取无参方法
         * @param obj
         * @param methodName
         * @return
         */
        public static Object invokeInstanceMethod(Object obj, String methodName) {
            Class[] pareTyples = new Class[]{};
            Object[] pareVaules = new Object[]{};
    
            return invokeInstanceMethod(obj, methodName, pareTyples, pareVaules);
        }
    
    
        /**
         * 无参静态方法
         * @param className
         * @param method_name
         * @return
         */
        public static Object invokeStaticMethod(String className, String method_name) {
            Class[] pareTyples = new Class[]{};
            Object[] pareVaules = new Object[]{};
    
            return invokeStaticMethod(className, method_name, pareTyples, pareVaules);
        }
    
        /**
         * 获取一个参数的静态方法
         * @param className
         * @param method_name
         * @param pareTyple
         * @param pareVaule
         * @return
         */
        public static Object invokeStaticMethod(String className, String method_name, Class pareTyple, Object pareVaule) {
            Class[] pareTyples = new Class[]{pareTyple};
            Object[] pareVaules = new Object[]{pareVaule};
    
            return invokeStaticMethod(className, method_name, pareTyples, pareVaules);
        }
    
        /**
         * 获取多个参数的静态方法
         * @param className
         * @param method_name
         * @param pareTyples
         * @param pareVaules
         * @return
         */
        public static Object invokeStaticMethod(String className, String method_name, Class[] pareTyples, Object[] pareVaules) {
            try {
                Class obj_class = Class.forName(className);
                return invokeStaticMethod(obj_class, method_name, pareTyples, pareVaules);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            return null;
        }
    
        /**
         * 无参静态方法
         * @param method_name
         * @return
         */
        public static Object invokeStaticMethod(Class clazz, String method_name) {
            Class[] pareTyples = new Class[]{};
            Object[] pareVaules = new Object[]{};
    
            return invokeStaticMethod(clazz, method_name, pareTyples, pareVaules);
        }
    
        /**
         * 一个参数静态方法
         * @param clazz
         * @param method_name
         * @param classType
         * @param pareVaule
         * @return
         */
        public static Object invokeStaticMethod(Class clazz, String method_name, Class classType, Object pareVaule) {
            Class[] classTypes = new Class[]{classType};
            Object[] pareVaules = new Object[]{pareVaule};
    
            return invokeStaticMethod(clazz, method_name, classTypes, pareVaules);
        }
    
        /**
         * 多个参数的静态方法
         * @param clazz
         * @param method_name
         * @param pareTyples
         * @param pareVaules
         * @return
         */
        public static Object invokeStaticMethod(Class clazz, String method_name, Class[] pareTyples, Object[] pareVaules) {
            try {
                Method method = clazz.getDeclaredMethod(method_name, pareTyples);
                method.setAccessible(true);
                return method.invoke(null, pareVaules);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            return null;
        }
    
    
        public static Object getFieldObject(String className, Object obj, String filedName) {
            try {
                Class obj_class = Class.forName(className);
                return getFieldObject(obj_class, obj, filedName);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public static Object getFieldObject(Class clazz, Object obj, String filedName) {
            try {
                Field field = clazz.getDeclaredField(filedName);
                field.setAccessible(true);
                return field.get(obj);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            return null;
        }
    
    
        public static void setFieldObject(Class clazz, Object obj, String filedName, Object filedVaule) {
            try {
                Field field = clazz.getDeclaredField(filedName);
                field.setAccessible(true);
                field.set(obj, filedVaule);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        public static void setFieldObject(String className, Object obj, String filedName, Object filedVaule) {
            try {
                Class obj_class = Class.forName(className);
                setFieldObject(obj_class, obj, filedName, filedVaule);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    
    
        public static Object getStaticFieldObject(String className, String filedName) {
            return getFieldObject(className, null, filedName);
        }
    
        public static Object getStaticFieldObject(Class clazz, String filedName) {
            return getFieldObject(clazz, null, filedName);
        }
    
        public static void setStaticFieldObject(String classname, String filedName, Object filedVaule) {
            setFieldObject(classname, null, filedName, filedVaule);
        }
    
        public static void setStaticFieldObject(Class clazz, String filedName, Object filedVaule) {
            setFieldObject(clazz, null, filedName, filedVaule);
        }
    }
    
     
    展开全文
  • java反射 java反射java反射java反射java反射java反射java反射java反射java反射java反射java反射java反射java反射java反射
  • 使用反射设置好了私有属性,在不使用setAccessible(true)时候,为什么不能使用demo.getName()方法获取属性? ``` public class Test{ public static void main(String [] args) { Class clazz = Class.for...
  • 思考:在讲反射之前,先思考一个问题,java中如何创建一个对象,有哪几种方式? Java中创建对象大概有这几种方式: 1、使用new关键字:这是我们最常见的也是最简单的创建对象的方式 2、使用Clone的方法:无论何时...
  • java反射与EJBjava反射与EJBjava反射与EJBjava反射与EJBjava反射与EJBjava反射与EJB
  • Java反射

    万次阅读 多人点赞 2019-08-28 22:58:42
    Java反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性。这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。 用途 ...
  • 使用JOOR实现Java反射

    千次阅读 2017-01-04 11:26:35
    在前面的博客 Java反射使用 列举了Java反射的一些使用,下面介绍开源反射工具JOOR的使用。 只需几行代码就实现了前面博客中内部类的反射: public void testJoor(){ Reflect.on(...
  • Java反射和注解符的使用

    万次阅读 2019-05-22 14:00:27
    Java反射使用示例 1、访问构造方法 访问方法 返回值类型 说明 Class.getConstructors() Constructor型数组 获得所有访问权限为public的构造方法 Class.getDeclaredConstructors() ...
  • Java反射原理与使用

    万次阅读 2020-12-21 16:23:09
    当类加载器将类加载进jvm之后,jvm会创建每一个类的元数据对象(Class),java语言允许通过元数据对象动态的创建对象实例,这种机制就称为java反射机制,基本上所有框架的底层都用到了反射机制,spring、mybatis、servlet...
  • java反射

    千次阅读 2018-01-23 18:02:05
    java反射 java反射以及复制一个bean的值到另一个bean中。 深入理解Java反射 https://www.cnblogs.com/luoxn28/p/5686794.html java 使用BeanInfo实现bean实体与map之间的互相转换 ...
  • Java反射机制

    2011-10-10 18:09:52
    Java反射机制Java反射机制Java反射机制Java反射机制Java反射机制Java反射机制Java反射机制
  • Java-Java反射

    千次阅读 2017-07-03 12:41:31
    Java反射概述Java语言允许通过程序化的方式间接对Class进行操作。Class文件由类装载器装载后,在JVM中形成一份描述Class结构的元信息对象,通过该元对象可以获知Class的结构信息,如构造函数、属性和方法等。Java...
  • Java反射使用实例

    千次阅读 2018-03-30 11:55:06
    JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。...
  • java 反射——使用详解

    千次阅读 2016-05-22 14:08:59
    网上对于java反射的解释已经很多了,很多官方的语言我们并不能很好的理解。我在这里说的通俗些,java反射的作用就是让我们从java虚拟机里面生成的class来进行反序列化得到这个类的实例。那么它的用处就更加多了,...
  • 如何使用 Java 反射反射的用法及案例

    千次阅读 热门讨论 2019-01-30 15:54:40
    博主声明: 转载请在开头附加本文链接及作者信息,并标记为转载。本文由博主威威喵原创,请多... Java Reflection,称为 Java 反射,是Java基础部分的一个比较难的点。Reflection(反射)是被视为动态语言的关键,...
  • java 反射

    千次阅读 2016-10-08 10:31:54
    java 反射 http://www.imooc.com/learn/199 java 反射 Class类的使用 动态加载类 获取方法信息 基本的数据类型void关键字等都存在类类型 Class类的基本API操作的 Method类提供了一些操作方法的方法 获取成员变量...
  • Java 反射

    千次阅读 2012-09-19 20:53:27
    Java反射所需要的类并不多,主要有java.lang.Class类和java.lang.reflect包中的Field、Constructor、Method、Array类。 注意:Class类是Java反射的起源,针对任何一个你想探勘的类,只有先为它产生一个Class类的...
  • Java反射介绍

    万次阅读 多人点赞 2018-12-05 13:38:40
    JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。...
  • 本示例使用Java反射机制分别设置当前类的private、public属性以及其父类的private属性来说明如何通过Java反射机制设置属性值。(注:设置继承的父类属性时,无法通过当前类的Class对象直接获取其属性字段,须通过其...
  • Java基础之—反射(非常重要)

    万次阅读 多人点赞 2017-05-13 13:29:02
    JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。...
  • java反射常用方法

    千次阅读 2016-08-23 17:12:28
    JAVA反射使用手记  本篇文章为在工作中使用JAVA反射的经验总结,也可以说是一些小技巧,以后学会新的小技巧,会不断更新。本文不准备讨论JAVA反射的机制,网上有很多,大家随便google一下就可以了。  在开始之前...
  • Java反射精讲

    2020-09-30 15:35:53
    反射Java中重要的也是较难理解的内容; 本课程从反射的定义、作用、原理和使用出发,全方位帮你彻底搞定反射
  • Java反射Reflect的使用详解

    千次阅读 2019-08-18 17:53:34
    本文对反射的定义,反射使用过程中重要的、常用的类和方法进行了讲解,包括Class类,Constructor类,Field类,Method类的说明及使用。反射机制允许在运行时判断任意一个对象所属的类、构造任意一个类的对象、判断...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 407,640
精华内容 163,056
关键字:

java反射的使用

java 订阅