Java反射知识

Author：钟小湖
发布时间：July 1, 2020
243views
No comments
9522 words
Categories：代码生涯 Java基础

必要性：学习框架源码必备的前提知识。

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

反射的优势：

- 1.**可以在程序运行过程中，操作这些对象。**
- 2.可以解耦，提高程序的可扩展性。

Java代码在计算机中经历的三个阶段

（1）Source源代码阶段： *.java 被编译成 *.class 字节码文件。

（2）Class类对象阶段：*.class字节码文件被类加载器加载进内存，并将其封装成Class对象（用于在内存中描述字节码文件），Class对象将原字节码文件中的成员变量抽取出来封装成数组Field[],将原字节码文件中的构造函数抽取出来封装成数组Construction[]，在将成员方法封装成Method[]。当然Class类内不止这三个，还封装了很多，一般常用的就这三个。

（3）RunTime运行时阶段：创建对象的过程new。

![](https://cdn.xn2001.com/20200701154046)

### 获取Class对象的方式

获取Class对象的三种方式对应着java代码在计算机中的三个阶段

（1）【Source源代码阶段】 **Class.forName("全类名")**：将字节码文件加载进内存，返回Class对象。多用于配置文件，将类名定义在配置文件中。读取文件，加载类。

（2）【Class类对象阶段】 **类名.class**：通过类名的属性class获取。多用于参数的传递

（3）【Runtime运行时阶段】**对象.getClass()**：getClass()方法是定义在Objec类中的方法 。 多用于对象的获取字节码的方式

**同一个字节码文件(\*.class)在一次程序运行过程中，只会被加载一次，无论通过哪一种方式获取的Class对象都是同一个。**

```java
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() 
```

**Field：成员变量**

（1）设置值 void set(Object obj, Object value)

（2）获取值 get(Object obj)

（3）忽略访问权限修饰符的安全检查 setAccessible(true):暴力反射

### 成员变量们

下面是一个测试的实体类，我将一直用它。

```java
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);
    }
}
```

```java
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);
    }
}
```

```java
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);
    }
}
```

### 构造方法们

```java
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();

```java
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());
        }
    }
} 
```

![](https://cdn.xn2001.com/20200701183905)

![](https://cdn.xn2001.com/20200701184040)

**对于反射机制来说，在反射面前没有公有私有，都可以通过暴力反射解决。**

### 获取类名

getClass()方法是Object类的方法，需要注意一点获取的类名是**全类名**（带有路径）

```java
@Test
public void reflect7(){
    Class personClass = Person.class;
    String className = personClass.getName();
    System.out.println(className);
}
```

### 案例

写一个"框架"，**不能改变该类的任何代码的前提下**，可以帮我们创建任意类的对象，并且执行其中任意方法。

**实现**

（1）配置文件

（2）反射

**步骤**

（1）将需要创建的对象的全类名和需要执行的方法定义在配置文件中

（2）在程序中加载读取配置文件

（3）使用反射技术来加载类文件进内存

（4）创建对象

（5）执行方法

在src下新建一个配置文件pro.properties

```
className = reflect.demo.Person
methodName = eat
```

```java
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);
    }
}
```

参考：[大佬的有道云笔记][1]

[1]: https://note.youdao.com/ynoteshare1/index.html?id=128508bf6a04968eced81ede9ac1b304&type=note<hr class="content-copyright" style="margin-top:50px" /><blockquote class="content-copyright" style="font-style:normal">版权属于：乐心湖's Blog本文链接：<a class="content-copyright" href="https://www.xn2001.com/archives/520.html">https://www.xn2001.com/archives/520.html</a>声明：博客所有文章除特别声明外，均采用 <a href="https://creativecommons.org/licenses/by-sa/4.0/deed.zh" target="_blank" rel="nofollow noopener noopener" one-link-mark="yes">CC BY-SA 4.0 协议</a> ，转载请注明出处！</blockquote>

腾讯云社区邀请各位技术博主加入，福利多多噢！

Last modification：September 29th, 2020 at 12:22 am

如果觉得我的文章对你有用，请随意赞赏

Java反射知识

钟小湖 • 2020 年 07 月 01 日

必要性：学习框架源码必备的前提知识。

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

反射的优势：

- 1.**可以在程序运行过程中，操作这些对象。**
- 2.可以解耦，提高程序的可扩展性。

Java代码在计算机中经历的三个阶段

（1）Source源代码阶段： *.java 被编译成 *.class 字节码文件。

（3）RunTime运行时阶段：创建对象的过程new。

![](https://cdn.xn2001.com/20200701154046)

### 获取Class对象的方式

获取Class对象的三种方式对应着java代码在计算机中的三个阶段

（2）【Class类对象阶段】 **类名.class**：通过类名的属性class获取。多用于参数的传递

（3）【Runtime运行时阶段】**对象.getClass()**：getClass()方法是定义在Objec类中的方法 。 多用于对象的获取字节码的方式

**同一个字节码文件(\*.class)在一次程序运行过程中，只会被加载一次，无论通过哪一种方式获取的Class对象都是同一个。**

}
```

### 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() 
```

**Field：成员变量**

（1）设置值 void set(Object obj, Object value)

（2）获取值 get(Object obj)

（3）忽略访问权限修饰符的安全检查 setAccessible(true):暴力反射

### 成员变量们

下面是一个测试的实体类，我将一直用它。

```java
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;
    }

//重载有参方法
    public void eat(String food){
        System.out.println("eat..."+food);
    }
}
```

```java
public class ReflectDemo2 {
    public static void main(String[] args) throws Exception {
        Class p = Person.class;

//2.Field getField(String name)
        Field kk = p.getField("kk");
        System.out.println(kk);

```java
public class ReflectDemo3 {
    public static void main(String[] args) throws Exception {
        Class personClass = Person.class;

### 构造方法们

```java
public class ReflectDemo4 {
    public static void main(String[] args) throws Exception{
        Class personClass = Person.class;

System.out.println("==========================================");

System.out.println("=========================================");

### 成员方法们

**Method：方法对象**

（1）执行方法：Object invoke(Object obj, Object... args)

（2）获取方法名称：String getName();

```java
public class ReflectDemo5 {
    public static void main(String[] args) throws Exception{
        Class personClass = Person.class;

System.out.println("--------------------------------------------");

System.out.println("============================================");

![](https://cdn.xn2001.com/20200701183905)

![](https://cdn.xn2001.com/20200701184040)

**对于反射机制来说，在反射面前没有公有私有，都可以通过暴力反射解决。**

### 获取类名

getClass()方法是Object类的方法，需要注意一点获取的类名是**全类名**（带有路径）

```java
@Test
public void reflect7(){
    Class personClass = Person.class;
    String className = personClass.getName();
    System.out.println(className);
}
```

### 案例

写一个"框架"，**不能改变该类的任何代码的前提下**，可以帮我们创建任意类的对象，并且执行其中任意方法。

**实现**

（1）配置文件

（2）反射

**步骤**

（1）将需要创建的对象的全类名和需要执行的方法定义在配置文件中

（2）在程序中加载读取配置文件

（3）使用反射技术来加载类文件进内存

（4）创建对象

（5）执行方法

在src下新建一个配置文件pro.properties

```
className = reflect.demo.Person
methodName = eat
```

参考：[大佬的有道云笔记][1]

Leave a Comment Cancel reply

Java反射知识