Java反射机制
一切的操作都将使用Object完成,类,数组的引用都可以使用Object来接收
1,认识Class类
以前要是想知道一个类中的属性,成员变量,方法等等的信息的话,需要通过new这个类的对象才能得到这些信息,但是在Java中,也允许一个实例化对象找到一个类的完整的信息,这个类就是Class类,Class类是继承Object类的.
正常方式: 引入需要的"包.类"名称 -->通过new实例化-->取得实例化对象
反射方式: 实例化对象-->getClass()方法(从Object类中继承而来),这里是得到Class类对象-->得到完整的"包.类"名称
getClass()这个方法的返回值是Class类,实际上该类是Java反射的源头
在Class类中没有定义构造方法,那么得到Class类对象的方法有3种:
(1)使用forName()的静态方法实例化对象 (2) 类.class (3)对象.getClass()
package cn.reflect; class Demo{ } public class RefDemo01 { public static void main(String[] args) throws ClassNotFoundException { Class c1 = Class.forName("cn.reflect.Demo"); Class c2 = Demo.class; Class c3 = new Demo().getClass(); System.out.println("类名称:"+c1.getName()); System.out.println("类名称:"+c2); System.out.println("类名称:"+c3); } }
3种实例化Class对象的方式是一样的,但是forName()这个方式比较常用,它只需要传入类所在的位置的名称的字符串参数就可以了,这样使程序具有很大的灵活性.
2,Class类的使用
2.1通过无参构造函数实例化对象
Class类在开发中最常用的是,利用forName这个方法,传入完整的包.类的路径的字符串形式,来实例化一个类的对象
想要通过Class本身来实例化其他类的对象,则可以使用Class类中的newInstance()方法来完成,但是要保证被实例化的类中存在这一个无参的构造方法
(1)forName传入需要实例化的类的完整包.类名称
(2)使用newInstance()方法,是实例化需要被实例化的对象,需要强转
package cn.reflect; class Person{ private String name; private int age; public Person(){ }//被实例化的对象必须存在无参构造方法 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 class RefInstance { public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException { Class clazz = Class.forName("cn.reflect.Person"); Person p = (Person)clazz.newInstance(); p.setName("wjd"); p.setAge(25); System.out.println("name:"+p.getName()+" age:"+p.getAge());//name:wjd age:25 } }
上述代码中,Person类并没有new一个新的对象,而是通过Class类,来完成了对Person类中的属性的访问.一般做在使用Class类来实例化对象时,一定要在类中编写无参的构造方法
2.2调用有参构造实例化对象
(1)通过Class类中的getConstructors()取得本类中的所有的构造方法
(2)向构造方法中传递一个对象数组中去,里面包含了构造方法是所需的各个参数
(3)通过Constructor实例化对象
package cn.reflect; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; class Worker{ private String name; private int age; public Worker(String name,int age){ this.setName(name); this.setAge(age); } public void setName(String name){ this.name = name; } public String getName(){ return name; } public void setAge(int age){ this.age = age; } public int getAge(){ return age; } } public class InstanceDemo01 { public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { Class c = Class.forName("cn.reflect.Worker"); Constructor[] con = c.getConstructors(); Worker worker = (Worker)con[0].newInstance("吴杰栋",25);//Worker中构造方法中有参数的,这里实例化的时候传参数,注意顺序,只有一个构造函数,所以数组中的0就可以 System.out.println("age:"+worker.getAge() +" name:"+ worker.getName()); } }
在上述代码中,newInstance()方法是Constructor类中的, 查看API可以发现这个方法中传入的参数都是对象,25其实是Integer对象(在使用是进行了自动拆箱)
在java类中是有可能存在多个构造函数的,它们只是构造函数中的参数类型不同而已,在API中,查阅到Class类中newIntance()这个类只能获取到带有无参构造函数的对象,那么带有参数的构造函数的时候,我们该如何获取该类的对象呢?
(1),构造函数没有参数的时候,产生该类对象,直接通过Class类中的newIntance()来获取
(2).构造函数有参数的时候,通过Class类中getConstructor()方法,在方法中传入构造函数参数类型的class文件,返回值是一个Constructor对象,查阅API发现在Constructor这个类中,也有一个带这参数类型的newIntance的方法,这样就能获取到带有参数类型的构造函数的类的对象了
package cn.reflect; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; //拿Person类中的构造函数 public class ReflectDemo2 { public static void main(String[] args) throws Exception { //createNewObject(); createNewObject_2(); } public static void createNewObject_2() throws NoSuchMethodException, SecurityException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { String name = "cn.bean.Person"; Class<?> clazz = Class.forName(name); //获取到了Person中带有参数类型的构造方法 Constructor<?> con = clazz.getConstructor(int.class,String.class); //这里通过constructor类中的方法来初始化类 Object obj = con.newInstance(23,"wjd"); } public static void createNewObject() throws Exception{ String name = "cn.bean.Person"; //找寻该文件的类文件并加载进内存,并产生class对象 Class<?> clazz = Class.forName(name); //产生该类的对象 Object obj = clazz.newInstance(); } }
3,反射的应用---得到类的属性
在反射中得到一个类的完成结构的话,使用到java.lang.reflect包中的以下几个类
(1) Constructor:表示类中的构造方法 (2)Field:表示类中的属性 (3)Method:表示类中的方法
Constructor类中常用的方法
|
序号 |
方法 |
描述 |
|
1 |
public int getModifiers() | 得到构造函数的修饰符 |
|
2 |
public String getName() | 得到构造函数的名称 |
|
3 |
public Class<?>[] getParameterTypes() | 得到构造函数中的参数类型 |
|
4 |
public String toString() | 返回此构造函数的信息 |
|
5 |
public T newInstance(Object... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException | 向构造函数中传入参数,实例化对象,就是需要拿到有参数构造函数的类的对象的时候,就需要用到这个 |
Field类中常用的方法
|
序号 |
方法 |
描述 |
| 1 | public Object get(Object obj) throws IllegalArgumentException, IllegalAccessException | 得到一个对象中属性的内容 |
| 2 | public void set(Object obj, Object value) throws IllegalArgumentException, IllegalAccessException | 设置指定对象中属性的具体内容 |
| 3 | public int getModifiers() | 得到属性的修饰符 |
| 4 | public String getName() | 返回此属性的名称 |
| 5 | public String toString() | 返回此Field类的信息 |
| 6 | public void setAccessible(boolean flag) throws SecurityException | 设置一个属性是否被外部访问(需要访问私有属性需要用这个方法true一下)暴力访问 |
| 7 | public static void setAccessible(AccessibleObject[] array, boolean flag) throws SecurityException | 设置一组属性是否被外部访问 |
Method类中常用的方法
| 序号 | 方法 | 描述 |
| 1 | public int getModifiers() | 得到方法的访问修饰符 |
| 2 | public String getName() | 得到方法的名称 |
| 3 | public Class<?>[] getParameterTypes() | 得到方法的全部参数类型 |
| 4 | public Class<?> getReturnType() | 得到方法的全部返回值类型 |
| 5 | public Class<?>[] getExceptionTypes() | 得到一个方法全部抛出的类型 |
| 6 | public Object invoke(Object obj, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException | 当通过反射得到类的对象,类的方法的名称,方法中的参数的时候,用这个方法,我们就能完美的运行该类 |
这三个类都是AccessibleObject类的子类
以上三个类基本覆盖了反射所需要用到的类包括类中的方法,必须要熟练记忆
在反射操作中,得到一个类中的全部属性,有两种不同的操作
(1)得到实现的接口或者父类中的公共属性 在Class类中的getFields()方法
(2)得到本类中的所有属性,包括私有属性 在Class类中的getDeclaredFields()
根据以前学过的知识,要想操作一个类中的属性,肯定得要先得到一个类的对象,那么在反射中,也不例外,也需要通过newIntance()来得到一个类的对象,这样才能去取得类中的属性
总之你想得到我的属性,必须给我对象
package cn.reflect; import java.lang.reflect.Field; //拿Person类中的字段 public class ReflectDemo3 { /** * @param args * @throws Exception */ public static void main(String[] args) throws Exception { getField(); } //拿到字节码文件的中的字段 public static void getField() throws Exception { Class<?> clazz = Class.forName("cn.bean.Person"); //拿到Person类中的age对象,返回的是一个Field的对象 //Field f = clazz.getField("age");//只能获取共有的的 Field field = clazz.getDeclaredField("age");//可以获取本类.包含私有 //对私有的属性,取消其权限的检查,暴力访问 field.setAccessible(true); //设置属性的时候,必须要用对象来设置属性,所以必须先弄个对象出来 Object obj = clazz.newInstance(); field.set(obj, 23); Object o = field.get(obj); System.out.println(o); } }
4,反射的应用---得到类中的方法
得到类中的方法,是使用Class类中的getMethod()方法,此方法返回的是一个Method类的对象数组
需要运行一个类
(1)需要先得到该类的方法,方法中的参数的class对象
(2)然后得到该类的对象
(3)调用Method中的invoke方法,将对象,和方法的参数传入该方法
package cn.reflect; import java.lang.reflect.Method; //获取Person类中的方法 public class ReflectDemo4 { public static void main(String[] args) throws Exception { // getMethod(); getMethod_2(); } public static void getMethod_2() throws Exception { Class<?> clazz = Class.forName("cn.bean.Person"); Method method = clazz.getMethod("paramMethod", String.class,int.class); //方法要运行起来,也需要对象的支持,所以要造个对象出来 Object obj = clazz.newInstance(); //Method中有个方法,能传入对象和方法,这样的话,方法就能完美的运行起来了 method.invoke(obj, "wjd",23); } public static void getMethod() throws Exception { Class<?> clazz = Class.forName("cn.bean.Person"); Method[] methods = clazz.getMethods();//这个获取的都是共有的方法 methods = clazz.getDeclaredMethods();//只能获取本类中的方法,但是包含了私有的方法 for(Method method : methods){ System.out.println(method); } } }
5,反射的应用---得到类中的的字段(暴力访问的话,可以得到类中的私有字段)
package cn.reflect; import java.lang.reflect.Field; //拿Person类中的字段 public class ReflectDemo3 { /** * @param args * @throws Exception */ public static void main(String[] args) throws Exception { getField(); } //拿到字节码文件的中的字段 public static void getField() throws Exception { Class<?> clazz = Class.forName("cn.bean.Person"); //拿到Person类中的age对象,返回的是一个Field的对象 //Field f = clazz.getField("age");//只能获取共有的的 Field field = clazz.getDeclaredField("age");//可以获取本类.包含私有 //对私有的属性,取消其权限的检查,暴力访问 field.setAccessible(true); //设置属性的时候,必须要用对象来设置属性,所以必须先弄个对象出来 Object obj = clazz.newInstance(); field.set(obj, 23); Object o = field.get(obj); System.out.println(o); } }
