反射机制:将类的各个组成部分封装为其他对象,这就是反射机制。
反射的优势:
- 1.可以在程序运行过程中,操作这些对象。
- 2.可以解耦,提高程序的可扩展性。
Java 代码在计算机中经历的三个阶段
(1)Source 源代码阶段: .java 被编译成 .class 字节码文件。
(2)Class 类对象阶段:*.class 字节码文件被类加载器加载进内存,并将其封装成 Class 对象(用于在内存中描述字节码文件),Class 对象将原字节码文件中的成员变量抽取出来封装成数组 Field [], 将原字节码文件中的构造函数抽取出来封装成数组 Construction [],在将成员方法封装成 Method []。当然 Class 类内不止这三个,还封装了很多,一般常用的就这三个。
(3)RunTime 运行时阶段:创建对象的过程 new。
获取Class对象的方式
获取 Class 对象的三种方式对应着 java 代码在计算机中的三个阶段
(1)【Source 源代码阶段】 Class.forName ("全类名"):将字节码文件加载进内存,返回 Class 对象。多用于配置文件,将类名定义在配置文件中。读取文件,加载类。
(2)【Class 类对象阶段】 类名.class:通过类名的属性 class 获取。多用于参数的传递
(3)【Runtime 运行时阶段】对象.getClass ():getClass () 方法是定义在 Objec 类中的方法 。 多用于对象的获取字节码的方式
同一个字节码文件 (*.class) 在一次程序运行过程中,只会被加载一次,无论通过哪一种方式获取的 Class 对象都是同一个。
public class ReflectDemo1 {
public static void main(String[] args) throws Exception {
Class<?> cls1 = Class.forName("reflect.demo.Person");
System.out.println("cls1 = " + cls1);
Class cls2 = Person.class;
System.out.println("cls2 = " + cls2);
Person person = new Person();
Class cls3 = person.getClass();
System.out.println("cls3 = " + cls3);
// == 比较三个对象
System.out.println("cls1 == cls2 : " + (cls1 == cls2)); //true
System.out.println("cls1 == cls3 : " + (cls1 == cls3)); //true
}
}
Class对象功能
方法名带 Declared
获取成员变量们
Field[] getFields() :获取所有public修饰的成员变量
Field getField(String name) 获取指定名称的 public修饰的成员变量
Field[] getDeclaredFields() 获取所有的成员变量,不考虑修饰符
Field getDeclaredField(String name)
获取构造方法们
Constructor<?>[] getConstructors()
Constructor<T> getConstructor(类<?>... parameterTypes)
Constructor<?>[] getDeclaredConstructors()
Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
获取成员方法们
Method[] getMethods()
Method getMethod(String name, 类<?>... parameterTypes)
Method[] getDeclaredMethods()
Method getDeclaredMethod(String name, 类<?>... parameterTypes)
获取全类名(获取的式包名+类名)
String getName()
getSimpleName() 得到的就是类名
Field:成员变量
(1)设置值 void set (Object obj, Object value)
(2)获取值 get (Object obj)
(3)忽略访问权限修饰符的安全检查 setAccessible (true): 暴力反射
成员变量们
下面是一个测试的实体类,我将一直用它。
public class Person {
private String name;
private int age;
public String kk;
public Person() {
}
public Person(String name, int age, String kk) {
this.name = name;
this.age = age;
this.kk = kk;
}
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 "Person{" +
"name='" + name + '\'' +
", age=" + age +
", kk='" + kk + '\'' +
'}';
}
//无参方法
public void eat(){
System.out.println("eat...");
}
//重载有参方法
public void eat(String food){
System.out.println("eat..."+food);
}
}
public class ReflectDemo2 {
public static void main(String[] args) throws Exception {
Class p = Person.class;
//1、Field[] getFields()获取所有public修饰的成员变量
Field[] fields = p.getFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("=============================");
//2.Field getField(String name)
Field kk = p.getField("kk");
System.out.println(kk);
//获取成员变量kk的值 [也只能获取公有的,获取私有的或者不存在的字符会抛出异常]
Person person = new Person();
System.out.println(kk.get(person));
//设置属性kk的值
kk.set(person,"乐心湖");
System.out.println(person);
}
}
public class ReflectDemo3 {
public static void main(String[] args) throws Exception {
Class personClass = Person.class;
//Field[] getDeclaredFields():获取所有的成员变量,不考虑修饰符
Field[] declaredFields = personClass.getDeclaredFields();
for(Field filed : declaredFields){
System.out.println(filed);
}
System.out.println("===================================");
//Field getDeclaredField(String name)
Field kk = personClass.getDeclaredField("kk"); //private String d;
Person p = new Person();
kk.set(p,"乐心湖");
Object value = kk.get(p);
System.out.println("kk = " + value);
}
}
构造方法们
public class ReflectDemo4 {
public static void main(String[] args) throws Exception{
Class personClass = Person.class;
//Constructor<?>[] getConstructors()
Constructor[] constructors = personClass.getConstructors();
for(Constructor constructor : constructors){
//Constructor 对象reflect包下的 import java.lang.reflect.Constructor;
System.out.println(constructor);
}
System.out.println("==========================================");
//获取无参构造函数,不常用,一般是使用 personClass.newInStance()
//注意:Person类中必须要有无参的构造函数,不然抛出异常
Constructor constructor1 = personClass.getConstructor();
System.out.println("constructor1 = " + constructor1);
//获取到构造函数后可以用于创建对象
Object person1 = constructor1.newInstance();
//Constructor类内提供了初始化方法newInstance();方法
System.out.println("person1 = " + person1);
System.out.println("==========================================");
//获取有参的构造函数
//参数类型顺序要与构造函数内一致,且参数类型为字节码类型
Constructor constructor2 = personClass.getConstructor(String.class,int.class,String.class);
System.out.println("constructor2 = " + constructor2);
//创建对象
Object person2 = constructor2.newInstance("乐心湖", 23,"哈哈哈");
//获取的是有参的构造方法,就必须要给参数
System.out.println(person2);
System.out.println("=========================================");
//对于一般的无参构造函数,我们都不会先获取无参构造器之后在进行初始化。
//而是直接调用Class类内的newInstance()方法
Object person3 = personClass.newInstance();
System.out.println("person3 = " + person3);
//我们之前使用的 Class.forName("").newInstance;
//其本质上就是调用了类内的无参构造函数来完成实例化的
//故可以得出结论 我们以后在使用
//Class.forName("").newInstance; 反射创建对象时,一定要保证类内有无参构造函数
}
}
成员方法们
Method:方法对象
(1)执行方法:Object invoke (Object obj, Object... args)
(2)获取方法名称:String getName ();
public class ReflectDemo5 {
public static void main(String[] args) throws Exception{
Class personClass = Person.class;
//获取指定的方法
Method eat1 = personClass.getMethod("eat");
//执行方法
Person person = new Person();
//如果方法有返回值类型可以获取到,没有就为null
Object o1 = eat1.invoke(person);
//输出返回值 eat方法没有返回值,故输出null
System.out.println(o1);
System.out.println("--------------------------------------------");
//获取有参的构造函数 有两个参数 第一个方法名 第二个参数列表 ,不同的参数是不同的方法(重载)
Method eat2 = personClass.getMethod("eat", String.class);
Object o2 = eat2.invoke(person, "西瓜");
System.out.println(o2);
System.out.println("============================================");
//注意:获取到的方法名称不仅仅是我们在Person类内看到的方法
Method[] methods = personClass.getMethods();
for (Method method : methods) {
//继承下来的方法也会被获取到(当然前提是public修饰的)
System.out.println(method);
//getName()方法获取的方法名仅仅就是方法名(不带全类名),且不带有参数列表。
System.out.println(method.getName());
}
}
}
对于反射机制来说,在反射面前没有公有私有,都可以通过暴力反射解决。
获取类名(包名+类名)
getClass () 方法是 Object 类的方法,需要注意一点它获取的类名是全类名(带有路径)
@Test
public void reflect7(){
Class personClass = Person.class; //得到的是全类名
String className = personClass.getName(); //得到的是包名+类名
String className = personClass.getSimpleName(); //得到的就是类名
System.out.println(className); }
案例
写一个 "框架",不能改变该类的任何代码的前提下,可以帮我们创建任意类的对象,并且执行其中任意方法。
实现
(1)配置文件
(2)反射
步骤
(1)将需要创建的对象的全类名和需要执行的方法定义在配置文件中
(2)在程序中加载读取配置文件
(3)使用反射技术来加载类文件进内存
(4)创建对象
(5)执行方法
在 src 下新建一个配置文件 pro.properties
className = reflect.demo.Person
methodName = eat
public class RelefctDemo6 {
public static void main(String[] args) throws Exception {
//1.加载配置文件
//1.1创建Properties对象
Properties pro = new Properties();
//1.2加载配置文件,转换为一个集合
//1.2.1获取class目录下的配置文件 使用类加载器
ClassLoader classLoader = RelefctDemo6.class.getClassLoader();
InputStream is = classLoader.getResourceAsStream("pro.properties");
pro.load(is);
//2.获取配置文件中定义的数据
String className = pro.getProperty("className");
String methodName = pro.getProperty("methodName");
//3.加载该类进内存
Class cls = Class.forName(className);
//4.创建对象
Object obj = cls.newInstance();
//5.获取方法对象
Method method = cls.getMethod(methodName);
//6.执行方法
method.invoke(obj);
}
}