精华内容
下载资源
问答
  • 反射方法 的简单使用

    千次阅读 多人点赞 2020-06-07 19:26:41
    反射方法 的简单使用 文章目录反射方法 的简单使用获得字节码文件对象的三种方式用字节码文件对象来构建一个类的对象构造方法对象方法对象得到属性对象 获得字节码文件对象的三种方式 Object类的getClass方法 ...

    反射方法 的简单使用

    获得字节码文件对象的三种方式

    首先第一句,一切皆对象。类、属性、方法、构造器都是对象

    该篇文章其实就注重两个点、是否有declared前缀,带有private的记得调用setAccessible
    所涉及到的类:Class、Field、Construcotr、Method

    1. Object类的getClass方法

    2. 类型.class 属性

    3. Class.forName(“类的路径”)

      image-20200607161433834

    都为true,内存地址是一样的。在程序的运行中,Person的class文件只被加载了一次。
    注意:除了反射案例。在此赠送一套最新Java架构项目实战教程+大厂面试题库,想学的 点击此处免费获取,小白勿进哦

    image-20200607161626586

    也为true,可知只加载了一次

    image-20200607161907591

    也为true

    用字节码文件对象来构建一个类的对象

    image-20200607162932098

    字节码文件对象中包含:

    那么 这4个字节码文件对象中叫什么呢?

    java文件 字节码文件
    字节码文件对象
    构造方法 构造方法对象(类型Constructor)
    成员变量 成员变量对象(类型Field)
    成员方法 成员方法(类型Method)

    之前一直用new的形式来创建一个类的对象

    Person p = new Person()

    加粗部分是类的构造方法,因为对象是通过构造方法创建的

    用字节码文件中的构造器对象来创建一个类的对象——Constructor对象

    image-20200607165151665

    获得Constructor来创建对象

    注意:getDeclaredConstructor(Class<?>… parameterTypes)
    这个方法会返回指定参数类型的所有构造器,**包括public的和非public的,**当然也包括private的。
    getDeclaredConstructors()的返回结果就没有参数类型的过滤了。

    再来看getConstructor(Class<?>… parameterTypes)
    这个方法返回的是上面那个方法返回结果的子集,只返回制定参数类型访问权限是public的构造器。
    getConstructors()的返回结果同样也没有参数类型的过滤。

    用反射有什么好处呢?之前Spring ioc有讲。可以通过配置文件动态创建对象:

    来:

    创建一个a.txt用来存储要创建对象的 全路径名称,之后读取这个字符串,用class.forName创建就可以了。以Person为例

    image-20200607165644004

    获取名称后也可创建对象。

    构造方法对象

    四个访问修饰符:

    image-20200607171458965

    image-20200607174759323

    getConstrustors是获取公有的,所以只有一个

    image-20200607174902268

    getDeclaredConstructors这个就是得到所有的

    获取指定的构造器

    image-20200607175158291

    这是public的,如果不是public,使用getConstructor获得指定方法机会报NoSuchMethodException

    image-20200607175310534

    所以也是用带Declared的getDeclaredConstructor

    那么其他访问修饰符呢?

    image-20200607180232347

    私有的可以得到构造器,但是不能创建对象

    image-20200607180338222

    通过constructor.setAccessible(true)设置为可以访问

    方法对象

    它也有这些

    image-20200607180610378

    image-20200607180641434

    其他方法是因为还有Object的,当然这是public的,要所有的需要加上Declared

    先给Person加上getter与setter,以及该类的一个私有方法

    image-20200607181104007

    image-20200607181124194

    可以发现有以下的区别

    1.不带declared是得到所有的public修饰的method 包括从父类继承过来的Declared

    2.带declared是得到当前类中的所有Method

    image-20200607183830023

    注意,getMethod()是得到公有的方法,同样的也有getDeclaredMethod()

    同样的,如果将getName()这个方法的访问权限改为私有的,那么也将报 **IllegalAccessException **

    image-20200607184211889

    那么也是一样的,需要设置一下

    image-20200607184320224

    得到属性对象

    getField跟getDeclaredField,跟上面的一样的。因为这里是private

    image-20200607190400689

    展开全文
  • C#反射方法:程序集反射、类型反射、接口反射、类型成员反射   反射(原创推荐)  在程序中,当我们需要动态的去加载程序集的时候(将对程序集的引用由编译时推移到运行时),反射是一种很好的选择。反射为...

    C#反射方法:程序集反射、类型反射、接口反射、类型成员反射 

    编译时加载程序集
    下面先从一个简单的例子说起,假如我们有一个Point类如下所示:
    using System;
    public class Point
    {
         public int x;
         public int y;
         public void Print()
         {
              Console.WriteLine("[{0},{1}]",x,y);
             }
        }[url=]复制代码[/url]

    先将其编译成Point.dll文件,然后我们需要在Reflect.cs文件中用到这个类型:
    代码如下:
    using System;
    public class Reflect
    {
         public static void Main()
         {
              Point p=new Point();
              p.x=100;
              p.y=200;
              p.Print();
             }
        }[url=]复制代码[/url]

    然后我们编译这个文件,会发现抛出异常,告诉我们不存在Point类型,也就是说Point是一个未知类型,编译器根本不知道它,那怎么办了,这里我们需要在编译时对Point程序集进行引用,这样才能让编译器知道它,在很多应用程序开发框架中在我们编译项目的时候框架会自动进行程序集的引用,但是在这里我们的编译工作是手动进行的,因此我们也需要手动的引用程序集。下面是编译命令:
    csc /roint.dll Reflect.cs
    这样我们在编译Reflect.cs文件的过程中就实现了对Point程序集的引用,这样编译器就识别了程序集中Point类型信息。其实任何类型信息的使用都需要有程序集的引用,不然的话编译器会不认识这个类型,编译就无法通过。我们可能会想,我们在很多时候进行编译的时候并没有对哪个程序集进行引用么?不是没有,而是很多预定义的类型信息编译器会默认帮我们进行引用,不需要我们显示的进行引用,比如mscorlib程序集,它是.NET一个核心程序集,里面包含了很多常用的预定义的类型信息,因此C#编译器在编译的时候会默认对它进行引用,可能我们会想,我们怎么知道一段代码在编译的过程中它到底都引用了哪些程序集了,这里就需要借助于元数据,下面我们通过ildasm工具查看了编译好的Reflect.exe程序集中的元数据,我们只截取了其中一段进行说明。
    // Metadata version: v4.0.30319
    .assembly extern mscorlib
    {
    .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4..
    .ver 4:0:0:0
    }
    .assembly extern Point
    {
    .ver 0:0:0:0
    }

    从这段元数据中我们可以看出,这个程序集中包含了对Point程序集和mscorlib程序集的引用。
    利用反射实现延迟加载程序集
    在上面所举的例子中,所有对程序集的引用都是在编译时进行的,因此效率会比较高。但是在某些特定的情况下,我们需要对程序集进行延迟加载,即将对程序集的引用由编译时推移到运行时,反射是一种很好的选择,在最开始我们讲过,反射为.NET类型提供了高度的动态能力,包括:元数据的动态查询、绑定与执行、动态代码生成,这些功能的实现都离不开元数据。下面我们看看反射的具体实现。
    using System;
    using System.Reflection;

    class Test
    {
         public static void Main(string[] args)
         {
              string assemblyName=args[0];
              string typeName=args[1];
              string fieldName1=args[2]; 
              string fieldName2=args[3];
              string methodName=args[4];
              Assembly assembly=Assembly.Load(assemblyName);  //手动加载程序集
              Type type=assembly.GetType(typeName);           //获取程序集中的类型
              
              
    //查询
              MemberInfo[] mis=type.GetMembers();             //获取类型中的成员信息
              for(int i=0;i<mis.Length;i++)
              {
                   Console.WriteLine(mis);
                  }          
              
                  object obj=Activator.CreateInstance(type);  //创建对象实例
                  
                  
    //查询字段
                  FieldInfo field1=type.GetField(fieldName1);
                  FieldInfo field2=type.GetField(fieldName2);
                  field1.SetValue(obj,100);   //实例成员必须依附于对象实例才能赋值
                  field2.SetValue(obj,200);
                  
                  //查询方法
                  MethodInfo method=type.GetMethod(methodName);
                  
                  //调用方法
                  method.Invoke(obj,null);   //实例方法必须依附于对象实例才能执行
             }
        }[url=]复制代码[/url]

    这里我们在编译这段代码的时候并没有对Point程序集进行引用,而是将其推移到了运行时。在这段代码中Point类型并不存在,因此我们并不能Point类型来创建对象实例。但是下面的几个操作是针对于对象的实例成员进行的,他们需要依附于对象的实例,因此我们在这里根据在运行时加载进来的类型信息创建了一个对象,但是编译时类型信息是未知的。我们可以通过查看它的元数据得知它编译后并没有对Point程序集进行加载。
    那么运行时怎么对程序集进行加载了,这里我们就需要将需要加载的程序集的信息在入口点函数中以参数的形式传递进来,下面是运行时的命令:

    在这段命令中我们指出了运行时需要加载的程序集的名称和其中的类型的名称以及类型中的成员信息。由于类型信息在编译时是未知的,因此我们并不清楚在运行时会加载进来什么样的类型信息(需要通过传入的参数确定)。也就是说我们现在所进行的一些操作是针对一个不确定的类型的(如果我们事先并不了解Point的类型信息)。而在上面的代码中我们之所以能够对加载进来类型信息进行这样的处理,是因为我们事先已经对Point类型信息有所了解了,因此我们遵循了这样一个隐式的约定来对类型进行操作。但是在很多情况下我们是并不了解未来加载进来的类型信息它所遵循的约定。因此在运行时,反射需要做很多的校验工作,也就是说把本来应该在编译时做的校验工作都推移到了运行时,比如参数类型的兼容性以及所调用的方法是实例方法还是静态方法,因此反射的效率比较低。
    利用接口提高反射效率
    那么怎么样才能提高反射的效率了,很简单,我们需要明确约定,也就是说只有满足了约定信息的类型才能被加载进来,也因此我们对类型成员的处理必须是满足了这一约定的,这样双方都有了一个共同的约定。那么我们用什么来实现这一约定了,当然需要用到接口了。
       我们对上面的例子进行改进,通过对Point类型的观察,我们可以得到这样一个接口,我们先看接口的实现,并将其编译为IPoint.dll文件。
    using System;
    public interface IPoint
    {
         public int X{set;get;}
         public int Y{set;get;}
         
         void Print();
        }[url=]复制代码[/url]

    下面我们来实现Point类,并对其进行编译,注意:在编译时确保对IPoint.dll的引用。
    using System;
    public class Point :IPoint
    {
         private int x;
         private int y;
         
         public int X
         {
             set{this.x=value;}
             get{return x;}
             }
             
             public int Y
             {
                  set{this.y=value;}
                  get{return y;}
                 }
                 
         public void Print()
         {
              Console.WriteLine("[{0},{1}]",this.X,this.Y);
             }
        }[url=]复制代码[/url]

    下面我们再来看Reflect类的实现,在对其进行编译时同样需要对IPoint.dll进行引用。
    using System;
    using System.Reflection;

    class Test
    {
         public static void Main(string[] args)
         {
              string assemblyName=args[0];
              string typeName=args[1];
             
              Assembly assembly=Assembly.Load(assemblyName);  //手动加载程序集
              Type type=assembly.GetType(typeName);           //获取程序集中的类型
                    
                  IPoint obj=(IPoint)Activator.CreateInstance(type);  //通过接口创建对象实例
                  obj.X=100;
                  obj.Y=200;
                  obj.Print();          
             }
        }[url=]复制代码[/url]

    最后运行编译后的Reflect.exe文件,运行时同样需要传入程序集信息和类型信息。这里我们看到Point程序集和Reflect程序集在编译时都对IPoint程序集进行了引用,因此在Reflect程序集中,虽然在编译时并没有Point类型信息,但是有IPoint类型信息,因此我们通过这个接口很方便的实现了我们需要的操作,只要未来加载进来了类型是实现了IPoint接口的就可以了,这样在编译时就不需要进行大量的校验工作了,这些工作都还原到了运行时,因此使用接口来实现反射也大大提高了反射的性能。
    展开全文
  • Java——反射方法总结

    千次阅读 多人点赞 2020-03-07 18:16:09
    1. 获取Class类对象的方法 /* * Class Class.forName(String packageNameAndClassName); * Class 类的静态成员方法通过完整的包名.类名获取对应的.class文件的class对象 * 同时也可以作为.class文件加载的方式 *...

    1. 获取Class类对象的方法

    /*
     * Class Class.forName(String packageNameAndClassName);
     * Class 类的静态成员方法通过完整的包名.类名获取对应的.class文件的class对象
     * 同时也可以作为.class文件加载的方式
     * 
     * Class 类名.class;
     * 		通过类名.class方法,获取对应的.class对象,通常用于方法的参数类型
     * 
     * Class 类对象.getClass();
     * 		通过类对象获取对应.class的class类对象,方法参数或者说数据类型判断
     */
    
    package com.qfedu.a_code1;
    
    
    public class GetClassObject {
    	public static void main(String[] args) throws ClassNotFoundException {
    		System.out.println(123456);
    		
    		Class<?> forname = Class.forName("com.qfedu.a_code1.Person");
    		
    		Class<com.qfedu.a_code1.Person> cls= Person.class;
    		
    		Class<? extends Person> class1 = new Person().getClass();
    		
    		/*
    		 * .class文件占用的空间独一份,不管通过哪一种方式获取对应的class对象都是同一个对象
    		 */
    		
    		System.out.println(forname == cls);
    		System.out.println(cls == class1);
    		System.out.println(class1 == forname);
    		System.out.println("----------------");
    		
    		System.out.println(forname);
    		System.out.println(cls);
    		System.out.println(class1);
    		System.out.println(int.class);
    	}
    }
    

    2. 与构造方法有关的方法

    public Constructor[] getConstructors();
    	获取当前Class类对象对应Java文件中,所有【public修饰构造方法的类对象数组】
    	
    public Constructor[] getDeclaredConstructors();
    	【暴力反射】
    	获取当前Class类对象对应Java文件中,所有【构造方法的类对象数组】,包括私有化构造方法。
    public Constructor getConstructor(Class... initArgumentTypes);
    	根据指定的数据类型,来选择对应的构造方法,这里可能会抛出异常。
    	这里有且只能获取获取类内的指定数据类型public修饰构造方法类对象
    	Class: 约束数据类型,当前方法所需的参数类型
    		例如: 
    			这里需要int类型 int.class
    			这里需要String类型 String.class
    			之类需要Perosn类型 Person.class
    		异常:
    			NoSuchMethodException
    	... : 不定长参数
    		构造方法需要的参数类型是很多的,有可能无参数,有可能有参数。... 不定长参数
    		类约束使用,增强代码的普适性
    		例如:
    			这里无参数 () or (null)
    			参数类型int类型 (int.class)
    			参数类型int, String类型 (int.class, String.class)
    	initArgumentTypes:
    		参数名 初始化参数类型复数
    		
    public Constructor getDeclaredConstructor(Class... initArgumentTypes);
    	【暴力反射】
    	根据指定的数据类型,来选择对应的构造方法,这里可能会抛出异常。
    	这里可以获取指定参数类型私有化构造方法和非私有化构造方法
    	Class: 约束数据类型,当前方法所需的参数类型
    		例如: 
    			这里需要int类型 int.class
    			这里需要String类型 String.class
    			之类需要Perosn类型 Person.class
    		异常:
    			NoSuchMethodException
    	... : 不定长参数
    		构造方法需要的参数类型是很多的,有可能无参数,有可能有参数。... 不定长参数
    		类约束使用,增强代码的普适性
    		例如:
    			这里无参数 () or (null)
    			参数类型int类型 (int.class)
    			参数类型int, String类型 (int.class, String.class)
    	initArgumentTypes:
    		参数名 初始化参数类型复数
    		
    Object newInstance(Object... initArguments);
    	通过Constructor对象来调用,传入当前构造方法所需创建对象的初始化参数,创建对象。
    	Object: Object类是Java中所有类的基类,这里可以传入任意类型的参数
    	... : 不定长参数,因为Constructor类对象在获取的过程中,约束的参数个数都不确定,
    	这里使用不定长参数来传入数据
    
    package com.qfedu.a_code1;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.InvocationTargetException;
    
    
    public class GetConstructorObject {
    	public static void main(String[] args) 
    			throws NoSuchMethodException, 
    			SecurityException, InstantiationException, 
    			IllegalAccessException, IllegalArgumentException, InvocationTargetException, 
    			ClassNotFoundException {
    		/*
    		 * 指定的包名.类名获取对应的.class类对象
    		 */
    		Class<?> cls = Class.forName("com.qfedu.a_code1.Person");
    		
    		/*
    		 * 获取当前Person类内非私有化的构造方法
    		 */
    		Constructor<?>[] cons = cls.getConstructors();
    		for (Constructor<?> constructor : cons) {
    			System.out.println(constructor);
    		}
    		
    		System.out.println("---------------");
    		System.out.println();
    		
    		/*
    		 * 暴力反射,获取Person类内的所有构造方法,包括private修饰的私有化构造方法
    		 */
    		Constructor<?>[] declaredConstructors = cls.getDeclaredConstructors();
    		for (Constructor<?> constructor : declaredConstructors) {
    			System.out.println(constructor);
    		}
    		
    		System.out.println("--------------");
    		System.out.println();
    		
    		/*
    		 * 根据指定参数类型获取public修饰的构造方法对象
    		 * 如果没有指定参数类型的构造方法,运行异常
    		 */
    		Constructor<?> constructor1 = cls.getConstructor();
    		Constructor<?> constructor2 = cls.getConstructor(int.class);
    		Constructor<?> constructor3 = cls.getConstructor(int.class, String.class);
    		System.out.println(constructor1);
    		System.out.println(constructor2);
    		System.out.println(constructor3);
    		
    		System.out.println("---------------------");
    		System.out.println();
    		
    		/*
    		 * 通过暴力反射可以获取任意权限修饰符 符合参数要求的构造方法对象
    		 */
    		Constructor<?> declaredConstructor1 = cls.getDeclaredConstructor();
    		Constructor<?> declaredConstructor2 = cls.getDeclaredConstructor(String.class);
    		System.out.println(declaredConstructor1);
    		System.out.println(declaredConstructor2);
    		System.out.println("--------------");
    		System.out.println();
    		
    		/*
    		 * 通过无参数Constructor对象执行newInstance方法
    		 */
    		Person p1 = (Person) constructor1.newInstance();
    		System.out.println(p1);
    		System.out.println(new Person());
    		System.out.println(constructor3.newInstance(1, "ljw"));
    		System.out.println("--------------");
    		System.out.println();
    		
    		/*
    		 * 给予通过暴力反射获取到的非公开权限成员变量,成员方法,构造方法,操作权限
    		 */
    		declaredConstructor2.setAccessible(true);
    		Person p2 = (Person) declaredConstructor2.newInstance("ljw");
    		System.out.println(p2);
    	}
    }
    

    3. 与成员方法有关的方法

    Method[] getMethods();
    	获取类内所有public修饰的成员方法,包括从父类继承而来的public修饰方法。
    
    Method[] getDeclaredMethods();
    	暴力反射
    	获取类内所有成员方法,但是不包括从父类继承而来的方法。
    
    Method getMethod(String methodName, Class... parameterTypes);
    	根据指定的方法名和对应的参数类型,获取对应的public修饰的成员方法
    	methodName: 
    		方法名,指定获取的是哪一个方法
    	parameterTypes:
    		Class用于约束当前使用你的参数数据类型
    		... 不定长参数,方法参数个数,顺序,有参无参问题
    Method getDeclaredMethod(String methodName, Class... parameterTypes);
    	根据指定的方法名和对应的参数类型,获取对应的成员方法,包括私有化成员方法,但是不
    	包括从父类继承而来的方法
    	methodName: 
    		方法名,指定获取的是哪一个方法
    	parameterTypes:
    		Class用于约束当前使用你的参数数据类型
    		... 不定长参数,方法参数个数,顺序,有参无参问题
    Object invoke(Object obj, Object... arguments);
    	通过Method类对象调用,执行对应的方法,需要的参数
    	obj : 
    		执行当前方法的执行者
    	arguments:
    		Object... 不定长参数,当前方法执行所需的实际参数
    
    package com.qfedu.a_code1;
    
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    
    public class GetMethodObject {
    	public static void main(String[] args) 
    			throws ClassNotFoundException, 
    			NoSuchMethodException, SecurityException, 
    			InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    		/*
    		 * 根据指定的包名.类名 获取对应的.class文件类对象
    		 */
    		Class<?> cls = Class.forName("com.qfedu.a_code1.Person");
    		
    		/*
    		 * 获取类内所有public修饰的成员方法,包括从父类继承而来的方法
    		 */
    		Method[] methods = cls.getMethods();
    		for (Method method : methods) {
    			System.out.println(method);
    		}
    		System.out.println("-----------------");
    		System.out.println();
    		
    		/*
    		 * 获取类内所有成员方法,包括私有化成员方法,但是不包括从父类继承而来的方法
    		 */
    		Method[] declaredMethods = cls.getDeclaredMethods();
    		for (Method method : declaredMethods) {
    			System.out.println(method);
    		}
    		System.out.println("-------------");
    		System.out.println();
    		
    		/*
    		 * 根据指定的方法名和参数类型,获取类内public修饰的成员方法
    		 */
    		Method game1 = cls.getMethod("game");
    		Method game2 = cls.getMethod("game", String.class);
    		
    		System.out.println(game1);
    		System.out.println(game2);
    		
    		System.out.println("----------------");
    		System.out.println();
    		
    		/*
    		 * 根据制定的方法名和参数类型,获取类内private修饰的成员方法
    		 */
    		Method declaredMethod1 = cls.getDeclaredMethod("testPrivate");
    		Method declaredMethod2 = cls.getDeclaredMethod("testPrivate", String.class);
    		System.out.println(declaredMethod1);
    		System.out.println(declaredMethod2);
    		System.out.println("----------------");
    		System.out.println();
    		
    		Object obj = cls.getConstructor().newInstance();
    		/*
    		 * 执行public修饰的成员方法
    		 */
    		game1.invoke(obj);
    		game2.invoke(obj, "WOT");
    		System.out.println("----------------------");
    		System.out.println();
    		
    		/*
    		 * 通过暴力反射给予权限,执行私有化成员方法
    		 */
    		declaredMethod1.setAccessible(true);
    		declaredMethod1.invoke(obj);
    		
    		declaredMethod2.setAccessible(true);
    		declaredMethod2.invoke(obj, "111");
    	}
    }
    

    4. 与成员变量有关的方法

    Field[] getFields();
    	获取类内所有public修饰的成员变量
    Field[] getDeclaredFields();
    	获取类内所有成员变量,包括私有化成员方法
    
    Field getField(String fieldName);
    	获取指定变量名的成员变量对象,要求是public修饰的成员变量
    
    Field getDeclaredField(String fieldName);
    	获取指定变量名的成员变量对象,包括private私有化修饰的成员变量
    	
    void set(Object obj, Object value);
    	设置指定调用者中对应成员变量的数据
    	obj : 调用者
    	value: 对应当前成员变量需要赋值的内容
    Object get(Object obj);
    	获取指定调用者中指定成员变量的数据
    	obj: 调用者
    
    package com.qfedu.a_code1;
    
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    
    /*
     * 获取成员变量Filed对象
     */
    public class GetFieldObject {
    	public static void main(String[] args) throws ClassNotFoundException, 
    	NoSuchFieldException, SecurityException, 
    	InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
    		/*
    		 * 根据指定的包名.类名获取对应.class文件类对象
    		 */
    		Class<?> cls = Class.forName("com.qfedu.a_code1.Person");
    		
    		Field[] fields = cls.getFields();
    		for (Field field : fields) {
    			System.out.println(field);
    		}
    		System.out.println("--------------");
    		System.out.println();
    		
    		Field[] declaredFields = cls.getDeclaredFields();
    		for (Field field : declaredFields) {
    			System.out.println(field);
    		}
    		System.out.println("--------------");
    		System.out.println();
    		
    		Field field = cls.getField("test");
    		System.out.println(field);
    		System.out.println("---------------");
    		System.out.println();
    		
    		Field id = cls.getDeclaredField("id");
    		Field name = cls.getDeclaredField("name");
    		
    		System.out.println(id);
    		System.out.println(name);
    		System.out.println("---------------");
    		System.out.println();
    		
    		Object obj = cls.getConstructor().newInstance();
    		System.out.println(obj);
    		
    		field.set(obj, 20);
    		System.out.println(obj);
    		
    		id.setAccessible(true);
    		name.setAccessible(true);
    		
    		id.set(obj, 1);
    		name.set(obj, "ljw");
    		System.out.println(obj);
    		
    		System.out.println(field.get(obj));
    		System.out.println(id.get(obj));
    		System.out.println(name.get(obj));
    	}
    }
    
    展开全文
  • 在调用反射方法之后,@Autowired注入对象为空。 解决方法: method.invoke(object, parameters) 改成  method.invoke(spring.getBean("beanName"), parameters) 这样这个问题就解决了。 获取...

    在调用反射方法之后,@Autowired注入对象为空。

    解决方法:

    method.invoke(object, parameters)

    改成 

    method.invoke(spring.getBean("beanName"), parameters)

    这样这个问题就解决了。

    获取spring上下文的方法: https://www.cnblogs.com/yjbjingcha/p/6752265.html

    展开全文
  • C# 反射 方法 带参数是(委托型) 方法 (委托 ) { 委托1= 委托 }
  • 上一篇讲了 通过反射创建对象,这一篇说说 通过反射调用一个类的方法 如果看过了上一篇文章,那么这一篇就很好理解了 如同上一篇文章一样,主要的方法基本上都是通过 Class 这个类(是个入口) 1.得到方法 对象...
  • java 中通过反射创建对象
  • java之反射字段,反射方法

    千次阅读 2013-09-14 23:17:55
    反射字段: package heng.java.reflect.field; import java.lang.reflect.Field; public class ReflectFieldDemo { public static void main(String[] args) { /* * 获取类中的成员。反射字段。 ...
  • C++反射方法

    万次阅读 2010-05-18 10:55:00
    要实现反射主要就几点问题:1、每个要反射的类里定义一个回调函数(用来创建这个类实例)2、在程序开始时把每个要反射的类的回调函数以类名为键存入全局哈希表第一个问题我们使用继承就可以为每个类添加回调了第二个...
  • 反射方法使用户控件动态调用父页面的方法 文章转自HelloSnoopy:http://www.cnblogs.com/hellosnoopy/archive/2004/12/01/71312.html下面演示了用户控件调用父页面SetLaeble方法。父页面类型用反射的方法获取,这...
  • 如果是R.id 或者R.drawable ,可以通过 context.getResource().getIdentifier(name,"id",...经过测试发现R.styleable R.attr 获取不到,这种情况可以通过反射方法 /** * * @param context * @p
  • Java反射方法method.setAccessible(true)

    千次阅读 2017-04-17 15:30:39
    对于公共成员、默认(打包)访问成员、受保护成员和私有成员,在分别使用 Field、Method 或 Constructor 对象来设置或获得字段、调用方法,或者创建和初始化类的新实例的时候,会执行访问检查。 在反射对象中设置...
  • 我项目有个需求,就是把一些方法程序调用时拦截,然后把拦截到的方法方法所在的类,及调用该方法的所需参数,存进缓存系统中,然后搞个定时任务,从缓存里面取出这些东西,用java反射调用,之前拦截的方法,框架用...
  • java反射方法method.setAccessible(true)

    千次阅读 2015-01-15 10:09:57
    一般情况下,我们并不能对类的私有字段进行操作,利用反射也不例外,但有的时候,例如要序列化的时候,我们又必须有能力去处理这些字段,这时候,我们就需要调用AccessibleObject上的setAccessible()方法来允许这种...
  • 近期看到 invoke 方法第一个参数的另外一种传法,如下: public class Event { public static final String TAG= "Event"; public static void test(){ Log.d(TAG, "Event test: "); } } Class<?> aClass...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 58,768
精华内容 23,507
关键字:

反射方法