Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。
image.png
1、动态语言
是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。主要动态语言：Object-C、C#、JavaScript、PHP、Python、Erlang。
2、静态语言
与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++。

  • Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。Java的动态性让编程的时候更加灵活！
  • Java反射机制提供的功能
    • 在运行时判断任意一个对象所属的类
    • 在运行时构造任意一个类的对象
    • 在运行时判断任意一个类所具有的成员变量和方法
    • 在运行时获取泛型信息
    • 在运行时调用任意一个对象的成员变量和方法
    • 在运行时处理注解
    • 生成动态代理
  • 反射相关的主要API
    • java.lang.Class:代表一个类
    • java.lang.reflect.Method:代表类的方法
    • java.lang.reflect.Field:代表类的成员变量
    • java.lang.reflect.Constructor:代表类的构造器 ```java import org.junit.Test;

public class ReflectionTest {

  1. //反射之前，对于Person的操作
  2. @Test
  3. public void test(){
  5.     //1.创建类的对象
  6.     Person p1 = new Person("jay",21);
  8.     //2.调用对象,调用其内部的属性和方法
  9.     p1.age = 15;
  10.     System.out.println(p1.toString());
  12.     p1.show();
  14.     //在Person类的外部，不可以通过Person类的对象调用其内部私有的结构。
  15.     //比如：name、showNation以及私有的构造器。
  17. }

}

  1. ```java
  2. package github;
  4. public class Person {
  5.     private String name;
  6.     public int age;
  8.     public String getName() {
  9.         return name;
  10.     }
  12.     public void setName(String name) {
  13.         this.name = name;
  14.     }
  16.     public int getAge() {
  17.         return age;
  18.     }
  20.     public void setAge(int age) {
  21.         this.age = age;
  22.     }
  24.     public Person() {
  25.     }
  27.     public Person(String name, int age) {
  28.         this.name = name;
  29.         this.age = age;
  30.     }
  32.     private Person(String name) {
  33.         this.name = name;
  34.     }
  36.     @Override
  37.     public String toString() {
  38.         return "Person{" +
  39.                 "name='" + name + '\'' +
  40.                 ", age=" + age +
  41.                 '}';
  42.     }
  44.     public void show(){
  45.         System.out.println("你好，我是🔔");
  46.     }
  48.     private String showNation(String nation){
  49.         System.out.println("喷子实在太多了！！！" + nation);
  50.         return nation;
  51.     }
  52. }

1、使用反射，实现同上的操作

  1. import org.junit.Test;
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.Field;
  5. import java.lang.reflect.InvocationTargetException;
  6. import java.lang.reflect.Method;
  8. public class ReflectionTest {
  10.     //反射之后 ，堆与Person的操作
  11.     @Test
  12.     public void test2() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
  13.         Class clazz = Person.class;
  14.         //1.通过反射，创建Person类的对象
  15.         Constructor cons = clazz.getConstructor(String.class,int.class);
  16.         Object obj = cons.newInstance("Jon",18);
  17.         Person p = (Person) obj;
  18.         System.out.println(p.toString());
  19.         //2.通过反射，调用对象指定的属性和方法
  20.         //调用属性
  21.         Field age = clazz.getDeclaredField("age");
  22.         age.set(p,10);
  23.         System.out.println(p.toString());
  25.         //调用方法
  26.         Method show = clazz.getDeclaredMethod("show");
  27.         show.invoke(p);
  29.     }
  30. }

2、反射的强大：调用类的私有结构

  1. import org.junit.Test;
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.Field;
  5. import java.lang.reflect.Method;
  7. public class ReflectionTest {
  8.      //反射之后 ，堆与Person的操作
  9.     @Test
  10.     public void test2() throws Exception{
  11.         Class clazz = Person.class;
  12.         //1.通过反射，创建Person类的对象
  13.         Constructor cons = clazz.getConstructor(String.class,int.class);
  14.         Object obj = cons.newInstance("Jon",18);
  15.         Person p = (Person) obj;
  16.         System.out.println(p.toString());
  17.         //2.通过反射，调用对象指定的属性和方法
  18.         //调用属性
  19.         Field age = clazz.getDeclaredField("age");
  20.         age.set(p,10);
  21.         System.out.println(p.toString());
  23.         //调用方法
  24.         Method show = clazz.getDeclaredMethod("show");
  25.         show.invoke(p);
  27.         System.out.println("+++++++++++++++++++++++++");
  29.         //通过反射，是可以调用Person类的私有结构的。比如：私有的构造器、方法、属性
  30.         //调用私有的构造器
  31.         Constructor cons2 = clazz.getDeclaredConstructor(String.class);
  32.         cons2.setAccessible(true);
  33.         Person p1 = (Person) cons2.newInstance("kalo");
  34.         System.out.println(p1);
  36.         //调用私有的属性
  37.         Field name = clazz.getDeclaredField("name");
  38.         name.setAccessible(true);
  39.         name.set(p1,"Taoyao");
  40.         System.out.println(p1);
  42.         //调用私有的方法
  43.         Method showNation = clazz.getDeclaredMethod("LiNin", String.class);
  44.         showNation.setAccessible(true);
  45.         String nation = (String) showNation.invoke(p1,"FaceBook");
  46.         //相当于String nation = p1.showNation("FaceBook")
  47.         System.out.println(nation);
  48.     }
  50.     /**
  51.      * 疑问1：通过直接new的方式或反射的方式都可以调用公共的结构，开发中到底用那个？
  52.      * 建议：直接new的方式。
  53.      * 什么时候会使用：反射的方式。 反射的特征：动态性
  54.      * 疑问2：反射机制与面向对象中的封装性是不是矛盾的？如何看待两个技术？
  55.      * 不矛盾。
  56.      */
  57. }