精华内容
下载资源
问答
  • 为什么doExample01可以用int.class, doExample02必须用两个Object。![图片说明](https://img-ask.csdn.net/upload/201905/06/1557144206_167353.png) doExample01不会报错 ![图片说明]...
  • java.lang.IllegalArgumentException: wrong number of arguments at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) at sun.reflect.NativeConstructorAccessorImpl.newInstance...
  • 很多人学习反射的时候,回碰到的一个异常, 举个例子:这个类里面有四个构造函数 public class Person { public Person() { } public Person(String name) { this.name = name; } public Person(int age...

    很多人学习反射的时候,回碰到的一个异常,

    举个例子:这个类里面有四个构造函数

    public class Person {
    
    	public Person() {
    
    	}
    
    	public Person(String name) {
    		this.name = name;
    	}
    
    	public Person(int age) {
    		this.age = age;
    	}
    
    	public Person(String name, int age) {
    		this.age = age;
    		this.name = name;
    	}
    
    	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;
    	}
    
    	@Override
    	public String toString() {
    		return "[" + this.name + "  " + this.age + "]";
    	}
    
    	private String name;
    	private int age;
    }
    


    调用的时候

    	public static void test4(String className){
    		Class<?> demo1 = null;
    		try {
    			demo1=Class.forName(className);
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		}
    		
    		Person person1 = null;
    		Person person2 = null;
    		Person person3 = null;
    		Person person4 = null;
    		
    		Constructor<?> cons[] = demo1.getConstructors();
    		try {
    			person1 = (Person) cons[0].newInstance();
    			person2 = (Person) cons[1].newInstance("xxx");
    			person3 = (Person) cons[2].newInstance(22);
    			person4 = (Person) cons[3].newInstance("xxx",22);
    		} catch (Exception  e) {
    			e.printStackTrace();
    		}
    		
    		System.out.println(person1);
    		System.out.println(person2);
    		System.out.println(person3);
    		System.out.println(person4);
    	}

    这样子就会报错,原因在于,赋值的时候和构造函数里面顺序是相反的,希望网上教程不要拿过来复制,粘贴,自己也动动手,免得对初学者造成误导,写下!

    展开全文
  • 今天在写一个反射的例子的时候,遇到了java.lang.IllegalArgumentException: wrong number of arguments这个错误,后来看了源代码,才知道错误的原因,一个很低级的错误; 首先我的代码是这样写的:在我的jpa栏中注解...

    今天在写一个反射的例子的时候,遇到了java.lang.IllegalArgumentException: wrong number of arguments这个错误,后来看了源代码,才知道错误的原因,一个很低级的错误;

    首先我的代码是这样写的:在我的jpa栏中注解的那块代码中:

    <span style="font-family:SimSun;font-size:18px;">	public void parse(Object obj, String methodName,String chineseName,String EnlishName) {
    	Method[] ms = obj.getClass().getMethods();
    	for (Method m : ms) {
    		if (methodName.equals(m.getName())) {
    			HelloWorld hw = m.getAnnotation(HelloWorld.class);
    			try{
    				m.invoke(obj,(Object)chineseName,(Object)EnlishName);
    			}catch(Exception e){
    				e.printStackTrace();
    			}
    		}
    	}
    }</span>
    首先我把
    <span style="font-family:SimSun;font-size:18px;">m.invoke(obj,(Object)chineseName,(Object)EnlishName);</span>
    写成了 new Oject[]{chineseName,(Object)EnlishName},报这个错,然后我发现我解析的这个方法中是2个参数,我这样写,其实是传一个数组参数的,所以不对应;后来我就改成了
    <span style="font-family:SimSun;font-size:18px;">m.invoke(obj,chineseName,EnlishName);</span>
    还有就是:

    <span style="font-family:SimSun;font-size:18px;">public class MainTest {
    	public static void main(String[] args) {
    		TestCase tc = new TestCase("王五","wangwu");
    		ParseAnnotaion parseAnno = new ParseAnnotaion();
    //		System.out.print("方法  print():");
    //		System.out.println("   ------------------------------");
    //		parseAnno.parse(tc, "print", "zhangsan", "lisi");
    //		System.out.print("\n"+"方法 toString():");
    //		System.out.println("   --------------------------------");
    //		parseAnno.parse(tc, "toString", "", "");
    		parseAnno.parse(tc, "print", new String[]{"1","2"});
    	}
    	
    }</span>

    <span style="font-family:SimSun;font-size:18px;">
    	public String print(String[] str) {
    		System.out.println(str[0]+","+str[1]);
    		return str[0]+","+str[1];
    	}</span>


    <span style="font-family:SimSun;font-size:18px;">public void parse(Object obj, String methodName,String[] name) {
    		Method[] ms = obj.getClass().getMethods();
    		for (Method m : ms) {
    			if (m.isAnnotationPresent(HelloWorld.class)
    					&& methodName.equals(m.getName())) {
    				HelloWorld hw = m.getAnnotation(HelloWorld.class);
    				System.out.println("hw.chineseName:"+hw.chineseName());
    				System.out.println("hw.value:"+hw.enlishName());
    				try{
    					System.out.println("before invoke");
    					m.invoke(obj,name);
    					System.out.println("after invoke");
    				}catch(Exception e){
    					e.printStackTrace();
    				}
    			}
    		}
    	}</span>

    这种情况也报错
    java.lang.IllegalArgumentException: wrong number of arguments
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
    at java.lang.reflect.Method.invoke(Method.java:597)
    at com.rong.zhu.jpa.ParseAnnotaion.parse(ParseAnnotaion.java:42)
    at com.rong.zhu.jpa.MainTest.main(MainTest.java:17)

    原因是:

    由于print(String str[])方法只有一个String数组的参数所以这是编译器会把字符串数组当作一个可变长度参数传给对象str,而我们取得方法只有一个参数,所以就会出现wrong number of arguments的异常,我们只要把字符串数组强制转换为一个Object对象就可以解决这个异常了,m.invoke(obj,(Object)name);就解决了;



    展开全文
  • Android Jni反射Java方法,弹出对话框

    千次阅读 2016-06-09 11:36:03
    1、创建页面/** * @描述 C语言调用java反射方法 * @项目名称 App_imooc * @包名 com.android.imooc.jni * @类名 ReflectActivity * @author chenlin * @date 2012年6月9日 上午8:49:35 */public

    1、创建页面

    /**
     * @描述         C语言调用java反射方法
     * @项目名称      App_imooc
     * @包名         com.android.imooc.jni
     * @类名         ReflectActivity
     * @author      chenlin
     * @date        2012年6月9日 上午8:49:35
     */
    
    public class ReflectActivity extends Activity {
    
        static{
            System.loadLibrary("hello");
        }
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_jni_reflect);
        }
    
        public void reflect(View view){
            showFromC();
        }
    
        public void show(String msg){
            AlertDialog.Builder builder = new AlertDialog.Builder(this);
            builder.setTitle("反射方法调用");
            builder.setMessage(msg);
            builder.show();
        }
    
        public native void showFromC();
    }

    2、在Hello.c里创建方法
    JNIEXPORT void Java_com_android_imooc_jni_ReflectActivity_logFromC(JNIEnv* env, jobject obj) {

    3、获得java里 show方法的签名
    1)首先进入到项目的classes目录 E:\androidproject\App_imooc\bin\classes
    2)右键+shift打开窗口, 如图:
    这里写图片描述

    3)点击“在此处打开命令窗口”
    4)输入E:\androidproject\App_imooc\bin\classes> javap -s com.android.imooc.jni.ReflectAc
    tivity
    5)得到签名: (Ljava/lang/String;)V
    这里写图片描述

    4、在C方法里先得到反编译类

    //拿到字节吗
    jclass clazz = ( *env)->FindClass(env, "com/android/imooc/jni/ReflectActivity");
    //得到方法名称
    ( *env)->GetMethodID(env, clazz, "show", "(Ljava/lang/String;)V");
    //把C字符串转化为java字符串
    jstring str = (*env)->NewStringUTF(env,"hello world");
    //调用回调方法
    ( *env)->CallVoidMethod(env, obj, id, str);

    5、Hello.c完整代码

    JNIEXPORT void JNICALL Java_com_android_imooc_jni_ReflectActivity_showFromC(JNIEnv* env,
            jobject obj) {
        //拿到字节吗
        jclass clazz = ( *env)->FindClass(env, "com/android/imooc/jni/ReflectActivity");
        //获得方法id
        //jmethodID   (*GetMethodID)(JNIEnv*, jclass, const char*, const char*);
        jmethodID id = ( *env)->GetMethodID(env, clazz, "show", "(Ljava/lang/String;)V");
        //回调
        //void        (*CallVoidMethod)(JNIEnv*, jobject, jmethodID, ...);
        jstring str = (*env)->NewStringUTF(env,"hello world");
        ( *env)->CallVoidMethod(env, obj, id, str);
    }

    6、最后调用成后的效果:
    这里写图片描述

    7、注意,如果是中文,小心乱码问题,解决办法:
    右键hello.c文件–》属性–》选择UTF-8编码
    这里写图片描述

    8、Java自身反射简单示例:

    package com.java.basic.reflect;
    
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    
    /**
     * @描述         TODO
     * @项目名称      Javas
     * @包名         com.java.basic.reflect
     * @类名         SimpleDemo
     * @author      chenlin
     * @date        2009年11月9日 上午8:41:48
     */
    
    public class SimpleDemo {
    
        public void show(String str){
            System.out.println(str);
        }
    
        public void reflect(){
            try {
                Class clazz = SimpleDemo.class.getClassLoader().loadClass("com.java.basic.reflect.SimpleDemo");
                Method method = clazz.getDeclaredMethod("show", String.class);
                method.invoke(clazz.newInstance(), "hello world");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        public static void main(String[] args) {
            SimpleDemo demo = new SimpleDemo();
            demo.reflect();
        }
    }

    ———————————————————————
    有需求者请加qq:136137465,非诚勿扰
    (java 架构师全套教程,共760G, 让你从零到架构师,每月轻松拿3万)
    01.高级架构师四十二个阶段高
    02.Java高级系统培训架构课程148课时
    03.Java高级互联网架构师课程
    04.Java互联网架构Netty、Nio、Mina等-视频教程
    05.Java高级架构设计2016整理-视频教程
    06.架构师基础、高级片
    07.Java架构师必修linux运维系列课程
    08.Java高级系统培训架构课程116课时
    (送:hadoop系列教程,java设计模式与数据结构, Spring Cloud微服务, SpringBoot入门)
    ——————————————————————–

    展开全文
  • 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反射

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

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

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

    千次阅读 2016-07-28 16:50:30
    不管咋样,学java的,了解java反射非常有必要!什么是反射反射定义java官方文档给出了解释: Reflection is the ability of a program to query and modify its state during the execution. 意为:反射是在程序运行...
  • java利用反射实现文件的读取

    万次阅读 2020-10-11 00:06:56
    java反射 java从很早的版本开始就引入了反射机制,java如今的框架底层大部分也都是使用反射实现的。 这篇博客就去探索下java反射使用的方便之处。 要说java反射机制,肯定离不开Class这个类,我们从jdk的源码可以...
  • Java 反射

    千次阅读 2016-09-16 11:12:48
    一、Java 语言的反射机制在Java运行时环境中,对于任意一个类,能否知道这个类有哪些属性和方法?对于任意一个对象,能否调用它的任意一个方法? 答案是肯定的。这种动态获取类的信息以及动态调用对象的方法的功能...
  • Java反射java.lang.reflect)

    千次阅读 2019-04-15 14:12:50
    什么是Java反射 Java反射是一种可以让我们在代码运行的时候,动态地获取我们想要创建实例的类信息,使用获得到的类的信息来获得一个程序执行时的对象的一种方法,也就是说,使用反射这种方法,我们不需要在代码中...
  • Java-Java反射

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

    千次阅读 2018-06-02 17:09:03
    一:百度百科介绍JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性;这种动态获取信息以及动态调用对象方法的功能称为java语言的...
  • Java基础篇:反射机制详解

    万次阅读 多人点赞 2018-09-29 10:19:50
    反射Java的特征之一,是一种间接操作目标对象的机制,核心是JVM在运行的时候才动态加载类,并且对于任意一个类,都能够知道这个类的所有属性和方法,调用方法/访问属性,不需要提前在编译期知道运行的对象是谁,...
  • JAVA Reflect反射详解

    千次阅读 2018-06-01 19:48:41
    1.什么是java反射java的反射机制是指在运行状态中, 对于任意一个类,都能知道这个类的所有属性和方法; 对于任意一个对象,都能够调用它的任意一个属性和方法; 这种动态获取的类的信息,和动态调用对象的方法的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 88,839
精华内容 35,535
关键字:

反射java

java 订阅