反射:
一、反射的概述
反射:通过获取Class类的对象(字节码文件对象),通过这个Class类的对象获取它里面的成员方法(Method),构造方法(Constructor)以及成员变量(Field)
疑问:
既然反射能获得该对象的全部属性,那我New一个对象是不是也能达到相同效果
答案是否定的,new对象的时候无法获取私有的方法和属性,而通过反射能够获取全部,所以了解一个类最好的方法是反射.
面试题:
* 如何获取class字节码文件对象/Class的类对象
* 三种方式来获取这个class字节码文件对象:
* 1)Object中的getClass()
* 2)任何数据类型的静态属性class
* 3)Class类中的方法:
* forName(String className)
* forName("类路径")
*
*如果你自己玩,任意:第一种和第二种都可以
*
*但是,开发中使用第三种方式,forName方法中的参数是一个String类型,以后可以用字符串类型数据作为配置文件!
测试类
首先建立一个JavaBean对象(用于测试)
package org.westos_01;
public class Person {
private String name ;
int age ;
public String address ;
//公共的无参
public Person() {
}
//私有的带一个参数的构造方法
private Person(String name) {
this.name = name ;
}
//没有权限修饰符的带两个参数的构造方法
Person(String name,int age){
this.name = name ;
this.age =age ;
}
//公共的带三个参数的构造方法
public Person(String name,int age,String address) {
this.name = name ;
this.age =age ;
this.address = address;
}
//成员方法
//无参的,没有返回值
public void show() {
System.out.println("show Person");
}
//有参的,没有返回值的
public void method(String s) {
System.out.println("method"+s);
}
//有参的,并且有返回值的
public String getString(String s,int i) {
return s+i ;
}
//私有的
private void function() {
System.out.println("function Preson");
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", address=" + address + "]";
}
}
public class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException {
//如何获取class字节码文件对象
//创建Person对象
Person p1 = new Person() ;
Class c1 = p1.getClass() ; //获取class字节码文件对象
Person p2 = new Person();
Class c2 = p2.getClass() ;
System.out.println(p1==p2);//false
System.out.println(c1==c2);//true
System.out.println("------------------");
//数据类型的静态属性class
Class c3 = Person.class ;
System.out.println(c3==c2);
//开发中常用使用第三种方式
//public static Class<?> forName(String className)
//java.lang.ClassNotFoundException: Person
// Class c4 = Class.forName("Person") ;
//org.westos_01.Person
//参数:类路径:包名.类名
Class c4 = Class.forName("org.westos_01.Person") ;
System.out.println(c4==c2);
}
下面我们可以获取他的构造方法
有下面几种方法:
getConstructor(参数1,参数2) :获取公共的构造方法,里面的参数是该参数类型的静态属性class
getDecalredConstructor(参数1,参数2):获取指定的构造方法(包括私有..)
setAccessible(boolean b):取消Java语言的访问检查
getConstructors():Class 对象所表示的类的所有公共构造方法
getDeclaredConstructors():获取当前字节码文件对象中的所有的构造方法
注意:若是获取了私有的构造方法,在创建对象的时候,需要取消Java语言的访问检查.
public class ReflectDemo {
public static void main(String[] args) throws Exception {
//1)先获取Person类的字节码文件对象
Class c = Class.forName("org.westos_01.Person") ;
//2)//public Constructor<?>[] getConstructors()
//Class 对象所表示的类的所有公共构造方法
/**
* public org.westos_01.Person(java.lang.String,int,java.lang.String)
public org.westos_01.Person()
*/
//public Constructor<?>[] getDeclaredConstructors():获取当前字节码文件对象中的所有的构造方法
// Constructor[] cons = c.getConstructors() ;
/**
* public org.westos_01.Person(java.lang.String,int,java.lang.String)
org.westos_01.Person(java.lang.String,int)
private org.westos_01.Person(java.lang.String)
public org.westos_01.Person()
*/
/*Constructor[] cons = c.getDeclaredConstructors() ;
for(Constructor con : cons) {
System.out.println(con);
}*/
//如何获取单个的构造方法
//public Constructor<T> getConstructor(Class<?>... parameterTypes)
//如果是无参的,不用写;如果是有参的,getContStructor方法中的参数是当前参数类型的静态属性class
Constructor con = c.getConstructor() ;
//public org.westos_01.Person()
//获取当前构造的对象
// System.out.println(con);
// public T newInstance(Object... initargs):initrgs:实际参数
//表示示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例
Object obj = con.newInstance();
System.out.println(obj);
}
}
package org.westos_02;
import java.lang.reflect.Constructor;
/**
*通过反射获取构造方法并使用
*
* 比如:有参构造的形式
* Person p = new Person("高圆圆",27,"户县") ;
* System.out.println(p) ;
*
*/
public class ReflectDemo2 {
public static void main(String[] args) throws Exception {
//1)获取Person类的字节码文件对象
Class c = Class.forName("org.westos_01.Person") ;
//2)获取单个构造方法(公共的,带三个参数的)
//public Constructor<T> getConstructor(Class<?>... parameterTypes)
Constructor con = c.getConstructor(String.class,int.class,String.class) ;
// System.out.println(con);
//3)创建构造方法表示的该类的实例对象
Object obj = con.newInstance("高圆圆",27,"户县") ;
System.out.println(obj);
//Person [name=高圆圆, age=27, address=户县]
}
}
package org.westos_02;
import java.lang.reflect.Constructor;
/**
* private Person(String name) {
this.name = name ;
}
Person p = new Person("高圆圆") ;
System.out.println(p) ;
*
*/
public class ReflectDemo3 {
public static void main(String[] args) throws Exception {
//获取字节码文件对象
Class c = Class.forName("org.westos_01.Person") ;
//现在获取的那个构造方法是私有的
//public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
Constructor con = c.getDeclaredConstructor(String.class) ;
//创建该类的实例,通过con对象创建
// java.lang.IllegalAccessException: Class org.westos_02.ReflectDemo3 can not access a member of class org.westos_01.Person with modifiers "private"
// at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:102)
//public void setAccessible(boolean flag)
//。值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查
con.setAccessible(true);
Object obj = con.newInstance("高圆圆") ;
System.out.println(obj);
//Person [name=高圆圆, age=0, address=null]
}
}
获取成员变量
public Field[] getDeclaredFields():获取当前字节码文件对象中所有的字段
public Field[] getFields() //获取当前字节码文件对象中的所有的公共的成员变量
给获取的成员变量赋值
1.获取字节码对象
Class c = Class.forname("该类全包名")
Constructor con = c.getConstructor();
2.获取该对象
Object obj = con.newInstance();
3.获取该属性
Field f = c.getField("属性名");
4.为该属性赋值
//public void set(Object obj,Object value)
//参数1:表示给哪个对象设置当前字段的值
//参数2:表示给当前获取的哪个Field对象的字段设置一个新的值
f.set(obj,"属性值")
package org.westos_03;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import org.westos_01.Person;
/**
*通过反射获取成员变量,并使用
*
*/
public class ReflectDemo {
public static void main(String[] args) throws Exception {
//获取Person类的字节码文件对象
Class c = Class.forName("org.westos_01.Person");
//获取当前字节码文件对象中的所有的公共的成员变量
//public Field[] getDeclaredFields():获取当前字节码文件对象中所有的字段
//public Field[] getFields()
// Field[] fields = c.getFields() ;
Field[] fields = c.getDeclaredFields();
for(Field field:fields) {
System.out.println(field);
}
/**
* 之前要给Person类中的address赋值
* Person p =new Person() ;
* p.address= "北京" ;
*/
//获取构造方法(Constructor)对象
Constructor con = c.getConstructor() ;
Object obj = con.newInstance() ;
// System.out.println(obj);
//获取Field类对象
//public Field getField(String name):获取的是公共的字段
//参数name:表示当前字段的名称
Field addressFiled = c.getField("address") ;
//public void set(Object obj,Object value)
//参数1:表示给哪个对象设置当前字段的值
//参数2:表示给当前获取的哪个Field对象的字段设置一个新的值
addressFiled.set(obj, "北京");
System.out.println(obj);
System.out.println("-------------------------");
//给name字段赋值
//java.lang.NoSuchFieldException: name
//name是私有的,必须指定方法获取
//public Field getDeclaredField(String name):指定的字段
Field nameField = c.getDeclaredField("name") ;
// Field nameField = c.getField("name") ;
// java.lang.IllegalAccessException: Class org.westos_03.ReflectDemo can not access a member of
//class org.westos_01.Person with modifiers "private"
//因为是私有,应该取消Java语言访问检查
nameField.setAccessible(true);
nameField.set(obj, "高圆圆");
System.out.println(obj);
System.out.println("---------------------------");
Field ageField = c.getDeclaredField("age") ;
ageField.setAccessible(true);
ageField.set(obj,27);
System.out.println(obj);
}
}
获取成员方法并使用
//获取当前字节码文件对象中的所有的公共的成员方法(包括父类中的)
// public Method[] getMethods()
//所有的成员方法
//public Method[] getDeclaredMethods():
//获取单个公共的成员方法,Method
//调用public void show(){}
//public Method getMethod(String name, Class<?>... parameterTypes)
//参数1: 表示方法名
//参数2:表示当前方法的参数数据类型的静态class属性
//获取任意一个成员方法.
//public Method getDeclaredMethod(String name , Class<?>... parameterTypes)
//public Object invoke(Object obj, Object... args)
//参数1:指定的哪个对象上调用底层invoke(),
//参数2:表示的调用那个方法所传递的实际参数
步骤:
1.获取字节码对象
Class c = Class.forname("类的全包名");
2.获取该对象
Construct con = c.getConstruct();
Object obj =con.newInstance();
3.获取该方法
Method m = c.getMethod("方法名",参数Class属性)
4.调用该方法
m.invoke(obj,参数1,参数2......);
具体操作代码如下
package org.westos_04;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
/**
*通过获取成员方法并使用
*
*/
public class MethodReflectDemo {
public static void main(String[] args)throws Exception {
//通过反射获取Pereson字节码文件对象
Class c = Class.forName("org.westos_01.Person") ;
//获取当前字节码文件对象中的所有的公共的成员方法(包括父类中的)
// public Method[] getMethods()
//public Method[] getDeclaredMethods():所有的成员方法
// Method[] methods = c.getMethods() ;
/*Method[] methods = c.getDeclaredMethods() ;
for(Method method:methods) {
System.out.println(method);
}*/
/***
* 之前调用Person类中的show()
* Person p = new Person() ;
* p.show() ;
*/
//获取Constructor对象
Constructor con = c.getConstructor() ;
Object obj = con.newInstance() ;
//获取单个的成员方法,Method
//调用public void show(){}
//public Method getMethod(String name, Class<?>... parameterTypes)
//参数1: 表示方法名
//参数2:表示当前方法的参数数据类型的静态class属性
Method m1 = c.getMethod("show") ;
// obj.m1() ;
//public Object invoke(Object obj, Object... args)
//参数1:指定的哪个对象上调用底层invoke(),
//参数2:表示的调用那个方法所传递的实际参数
m1.invoke(obj) ; //在obj对象上调用m1对象所表示的成员方法
System.out.println("--------------------");
/**
* public void method(String s) {
System.out.println("method"+s);
}
*/
Method m2 = c.getMethod("method",String.class) ;
//调用底层方法
m2.invoke(obj, "hello") ;
System.out.println("-----------------------");
/**
* public String getString(String s,int i) {
return s+i ;
}
*/
Method m3 = c.getMethod("getString",String.class,int.class) ;
//调用Method类中的invoke()方法,调用底层哪个字节码文件对象的对应的成员方法
Object objgetString = m3.invoke(obj, "javaweb",100) ;
System.out.println(objgetString);
System.out.println("---------------------------");
/**
* //私有的
private void function() {
System.out.println("function Preson");
}
*/
//public Method getDeclaredMethod(String name , Class<?>... parameterTypes)
Method m4= c.getDeclaredMethod("function") ;
//取消Java语言访问检查
m4.setAccessible(true);
//调用obj 对象中的底层的function()方法
m4.invoke(obj) ;
}
}
3054
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
