我是靠谱客的博主 爱撒娇大船，最近开发中收集的这篇文章主要介绍java基础之反射(框架设计的灵魂)一、概念二、Class类对象阶段三、获取Class对象的方式四、Class对象功能五、案列六、总结，觉得挺不错的，现在分享给大家，希望可以做个参考。
概述
框架设计的灵魂：反射
- 一、概念
- 二、Class类对象阶段
- 1.概念
- 2.Field：成员变量
- 3.Constructor：构造方法
- 4.Method：方法对象
- 三、获取Class对象的方式
- 四、Class对象功能
- 1. 获取成员变量们
- 2. 获取构造方法们
- 3. 获取成员方法们
- 4. 获取全类名
- 五、案列
- 1.需求
- 2.实现
- 3.步骤
- 六、总结
一、概念
- 框架：半成品软件，可以在框架的基础上进行软件开发，简化编码
- 反射：将类的各个组成部分封装为其他对象，这就是反射机制
- 反射的好处：①可以在程序运行过程中，操作这些对象 ②可以解耦，提高程序的可扩展性
- Java代码实现时，在计算机中经历的三个阶段：Source 源代码阶段、Class类对象阶段、Runtime运行时阶段
二、Class类对象阶段
1.概念
源代码阶段字节码文件通过类加载器（ClassLoader），加载进内存成为Class类对象，Class对象里面有三个重要属性：成员变量 Field [] fields、构造方法 Constructor [] constructors 、成员方法 Method [] methods
2.Field：成员变量
1.方法：
1. 设置值 void set(Object obj, Object value)
2. 获取值 get(Object obj)
3. 忽略访问权限修饰符的安全检查 setAccessible(true):暴力反射
3.Constructor：构造方法
1.创建对象：
1. T newInstance(Object... initargs)
2. 如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法
4.Method：方法对象
1.执行方法：Object invoke(Object obj, Object... args)
2.获取方法名称：String getName:获取方法名
三、获取Class对象的方式
- 第一阶段：Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象（多用于配置文件，将类名定义在配置文件中。读取文件，加载类）
- 第二阶段：类名.class：通过类名的属性class获取（多用于参数的传递）
- 第三阶段：对象.getClass()：getClass()方法在Object类中定义着（多用于对象的获取字节码的方式）
代码展示
package cn.hzuxyu.domain;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
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 +
'}';
}
}
package cn.hzuxyu.reflect;
import cn.hzuxyu.domain.Person;
public class ReflectDemo1 {
public static void main(String[] args) throws ClassNotFoundException {
//1.Class.forName("全类名")
Class class1 = Class.forName("cn.hzuxyu.domain.Person");
System.out.println(class1);
//2.类名.class
Class<Person> class2 = Person.class;
System.out.println(class2);
//3.对象.getClass()
Person P = new Person();
Class<? extends Person> class3 = P.getClass();
System.out.println(class3);
//== 比较三个对象
System.out.println(class1 == class2);
System.out.println(class1 == class3);
}
}
结果展示
结论： 同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。
四、Class对象功能
1. 获取成员变量们
Field[] getFields() 获取所有public修饰的成员变量
Field getField(String name) 获取指定名称的 public修饰的成员变量
Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符
Field getDeclaredField(String name)
代码展示
package cn.hzuxyu.domain;
public class Person {
private String name;
private int age;
public String a;
protected String b;
String c;
private String d;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
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 +
", a='" + a + ''' +
", b='" + b + ''' +
", c='" + c + ''' +
", d='" + d + ''' +
'}';
}
}
package cn.hzuxyu.reflect;
import cn.hzuxyu.domain.Person;
import java.lang.reflect.Field;
public class ReflectDemo2 {
public static void main(String[] args) throws Exception {
//0.获取Person的Class对象
Class personclass = Person.class;
//1.1Field[] getFields()获取所有public修饰的成员变量
Field[] fields = personclass.getFields();
for (Field field : fields) {
System.out.println(field);
}
//1.2Field getField(String name)获取指定的public修饰的成员变量
Field a = personclass.getField("a");
System.out.println(a);
System.out.println("-----------------------------------------------");
//1.2.1设置成员变量a的值
Person person = new Person();
a.set(person,"张三");
//1.2.2获取成员变量a的值
Object o = a.get(person);
System.out.println(o);
System.out.println("-----------------------------------------------");
//2.1Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符
Field[] fields1 = personclass.getDeclaredFields();
for (Field field : fields1) {
System.out.println(field);
}
System.out.println("-----------------------------------------------");
//2.2//Field getDeclaredField(String name)
Field d = personclass.getDeclaredField("d");
//忽略访问权限修饰符的安全检查
d.setAccessible(true);
Object o1 = d.get(person);
System.out.println(o1);
}
}
结果展示
注： 通过暴力反射可以访问私有变量
2. 获取构造方法们
Constructor<?>[] getConstructors()
Constructor<T> getConstructor(类<?>... parameterTypes)
Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
Constructor<?>[] getDeclaredConstructors()
代码展示
package cn.hzuxyu.reflect;
import cn.hzuxyu.domain.Person;
import java.lang.reflect.Constructor;
public class ReflectDemo3 {
public static void main(String[] args) throws Exception {
//0.获取Person的Class对象
Class personclass = Person.class;
//1.Constructor<T> getConstructor(类<?>... parameterTypes
Constructor constructor = personclass.getConstructor(String.class, int.class);
System.out.println(constructor);
//1.1创造对象
Object o = constructor.newInstance("张三", 19);
System.out.println(o);
System.out.println(" -------------------------------------------------------");
//使用空参方法
Constructor constructor1 = personclass.getConstructor();
//1.2创造对象
Object o1 = constructor1.newInstance();
System.out.println(o1);
System.out.println(" -------------------------------------------------------");
//直接使用Class中空参构造方法
//1.3创造对象
Object o2 = personclass.newInstance();
System.out.println(o2);
}
}
结果展示
如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法
3. 获取成员方法们
Method[] getMethods()
Method getMethod(String name, 类<?>... parameterTypes)
Method[] getDeclaredMethods()
Method getDeclaredMethod(String name, 类<?>... parameterTypes)
代码展示
package cn.hzuxyu.domain;
public class Person {
private String name;
private int age;
public String a;
protected String b;
String c;
private String d;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
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 +
", a='" + a + ''' +
", b='" + b + ''' +
", c='" + c + ''' +
", d='" + d + ''' +
'}';
}
public void eat(){
System.out.println("eat...");
}
public void eat(String food){
System.out.println("eat..."+food);
}
}
package cn.hzuxyu.reflect;
import cn.hzuxyu.domain.Person;
import java.lang.reflect.Method;
public class ReflectDemo4 {
public static void main(String[] args) throws Exception {
//0.获取Person的Class对象
Class personclass = Person.class;
Method eat_method1 = personclass.getMethod("eat");
Person person = new Person();
//执行方法
eat_method1.invoke(person);
System.out.println("-----------------------------------");
Method eat_method2 = personclass.getMethod("eat",String.class);
eat_method2.invoke(person,"饭");
System.out.println("---------------------------------------------------------");
//获取所有public修饰的方法
//Person类的父类Object的方法也会被获取
Method[] methods = personclass.getMethods();
for (Method method : methods) {
System.out.println(method);
}
System.out.println("---------------------------------------------------------");
//获取所有public修饰的方法名称
Method[] methods1 = personclass.getMethods();
for (Method method : methods1) {
String name = method.getName();
System.out.println(name); //打印方法名
}
}
}
结果展示
4. 获取全类名
String getName()
代码展示
package cn.hzuxyu.reflect;
import cn.hzuxyu.domain.Person;
import java.lang.reflect.Method;
public class ReflectDemo4 {
public static void main(String[] args) throws Exception {
//0.获取Person的Class对象
Class personclass = Person.class;
//1.获取类名
String className = personclass.getName();
System.out.println(className);
}
}
结果展示
五、案列
1.需求
写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法。
2.实现
- 配置文件
- 反射
3.步骤
-
将需要创建的对象的全类名和需要执行的方法定义在配置文件中
-
在程序中加载读取配置文
-
使用反射技术来加载类文件进内存
-
创建对象
-
执行方法
代码展示
package cn.hzuxyu.reflect;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;
public class ReflectTest1 {
public static void main(String[] args) throws Exception {
//1.加载配置文件
//1.1创建Properties对象
Properties pro = new Properties();
//1.2加载配置文件，转换为一个集合
//1.2.1获取class目录下的配置文件(找着文件)
ClassLoader classLoader = ReflectTest1.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);
}
}
结果展示
注： 加载配置文件，首先需要通过字节码文件对应的类加载器，再通过类加载器获取资源对应的字节流，最后加载进内存
六、总结
java基础之反射，就是这么简单。如果觉得还不错的话，就送我一个赞吧！如果本文对你有用的话，也欢迎收藏哦！
最后
以上就是爱撒娇大船为你收集整理的java基础之反射(框架设计的灵魂)一、概念二、Class类对象阶段三、获取Class对象的方式四、Class对象功能五、案列六、总结的全部内容，希望文章能够帮你解决java基础之反射(框架设计的灵魂)一、概念二、Class类对象阶段三、获取Class对象的方式四、Class对象功能五、案列六、总结所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复