Java反射删除_Java反射知识

反射机制：将类的各个组成部分封装为其他对象，这就是反射机制。

反射的优势：

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 的都是获取所有变量，不带则只能获取 publish 修饰的变量

获取成员变量们

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() 得到的就是类名

<em id="__mceDel"></em>

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)执行方法

在 old-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);

}

}