目录

1：什么是反射

2：怎么使用反射

3:反射作用

---

1：什么是反射

大家都知道，要让Java程序能够运行，那么就得让Java类要被Java虚拟机加载。Java类如果不被Java虚拟机加载，是不能正常运行的。现在我们运行的所有的程序都是在编译期的时候就已经知道了你所需要的那个类的已经被加载了。

Java的反射机制是在编译并不确定是哪个类被加载了，而是在程序运行的时候才加载、探知、自审。使用在编译期并不知道的类。这样的特点就是反射，体现了Java的动态性。

每一个类都会在编译之后都会产生.class文件，当这个类在第一次使用的时候类加载器(ClassLoader)会加载.class到jvm中，

加载：由类加载器完成，找到对应的字节码，创建一个Class对象

链接：验证类中的字节码，为静态域分配空间

初始化：如果该类有超类，则对其初始化，执行静态初始化器和静态初始化块（编译器将检查类型向下转型是否合法，如果不合法将抛出异常。向下转换类型前，可以使用instanceof判断。）

2：怎么使用反射

以下就是简单的方法示例，在测试代码中会详细举例

1：获取类

Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");

2：获取构造函数

Constructor<User> constructorsP1 = c3.getConstructor(int.class, String.class);

3：获取对象

User user = constructorsP.newInstance();

4：获取方法

Method m2 = c3.getDeclaredMethod("add",int.class);

m2.setAccessible(true);//私有需要强制才能执行

m2.invoke(user1,5);//执行方法

5：获取字段

Field field = c3.getDeclaredField("id");

field.setAccessible(true);

field.set(user, 1);

 第一步：首先要有一个目标类（用来验证反射）

//在类中有私有变量和共有变量 私有构造和共有构造
public class User {

    public String address;
    private int id;
    private String name;


    public User() {
        System.out.println("无参构造");
    }

    public User(int id, String name) {
        System.out.println("全部参数构造");
        this.id = id;
        this.name = name;
    }

    private User(int id) {
        System.out.println("私有id的构造函数");
        this.id = id;
    }

    private int add(int a){
        System.out.println("私有方法");
        int i=10;
        return a+i;
    }


    public int add1(int a){
        System.out.println("共有方法");
        int i=10;
        return a+i;
    }

    public static int add2(int a){
        System.out.println("静态方法");
        int i=10;
        return a+i;
    }

    @Override
    public String toString() {
        return "User{" +
                "address='" + address + '\'' +
                ", id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

第二步：我们使用反射得到类（反射得到类有三种方式，第三种实用性强）

@org.junit.Test
    public void t1() throws ClassNotFoundException {
        System.out.println("第一种获取反射类 new 对象,对象.class");
        User user = new User();
        Class c1 = user.getClass();
        System.out.println(c1);

        System.out.println("第二种获取反射类 类.class");
        Class c2 = User.class;
        System.out.println(c2);

        System.out.println("第三种获取反射类 Class.forName(全限定名字)");
        Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");
        System.out.println(c3);

        System.out.println("反射类只有一个 所以都相等 但是创建的对象不相等");
        System.out.println(c1 == c2);//true
        System.out.println(c2 == c3);//true


    }

第三步：通过得到类获取构造函数创建对象、获取字段、获取方法

/**
     * 反射获取类 类通过构造得到对象
     *
     * @throws ClassNotFoundException
     */
    @org.junit.Test
    public void t2() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {


        System.out.println("第三种获取反射类");
        Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");

        //获取所有的public的方法
        System.out.println("=============getConstructors获取所有public构造=================");
        Constructor[] constructors = c3.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println("所有的public构造：" + constructor);
        }
        System.out.println();


        //获取指定的public的方法
        System.out.println("=============getConstructor获取指定public构造=================");
        Constructor<User> constructorsP = c3.getConstructor(null);
        Constructor<User> constructorsP1 = c3.getConstructor(int.class, String.class);

        //实例化对象 无参构造不能写参数constructorsP.newInstance(1,"22");
        User user = constructorsP.newInstance();
        System.out.println(user);//输出对对象
        System.out.println(user.add1(2));//调用方法

        User user1 = constructorsP1.newInstance(1, "郑州");
        System.out.println(user1);
        System.out.println(user1.add1(3));


        System.out.println("公有无参构造：" + constructorsP);
        System.out.println("公有两个参数构造：" + constructorsP1);

        System.out.println();


        //获取所有的public,private的方法
        System.out.println("=============getDeclaredConstructors获取所有public，private构造=================");
        Constructor[] constructors1 = c3.getDeclaredConstructors();
        for (Constructor constructor : constructors1) {
            System.out.println("所有的public、peivate构造：" + constructor);
        }
        System.out.println();


        //获取指定的的private的方法
        System.out.println("=============getDeclaredConstructor获取private构造=================");
        Constructor constructors11 = c3.getDeclaredConstructor(int.class);
        System.out.println("私有一个参数构造：" + constructors11);

        System.out.println();

        System.out.println(c3);


    }


    /**
     * 反射获取类 类获取到字段
     *
     * @throws ClassNotFoundException
     */
    @org.junit.Test
    public void t3() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {


        System.out.println("第三种获取反射类");
        Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");

        //获取无参构造 并且创建对象
        Constructor<User> userConstructor = c3.getConstructor(null);
        User user = userConstructor.newInstance();

        System.out.println("");
        System.out.println("===========getFields获取所有的共有字段===========");
        Field[] fields = c3.getFields();
        for (Field field : fields) {
            field.set(user, "北京");
            System.out.println(field);
        }
        System.out.println("私有属性的User:" + user);


        System.out.println();
        System.out.println("===========getDeclaredFields获取所有的字段(public private)===========");
        Field[] fields1 = c3.getDeclaredFields();
        for (Field field : fields1) {
            System.out.println(field);
        }

        System.out.println();
        System.out.println("===========getDeclaredField获取私有和共有  getField获取共有的指定字段===========");

        Field field = c3.getDeclaredField("id");
        field.setAccessible(true);
        field.set(user, 1);
        field = c3.getDeclaredField("name");//获取私有
        field.setAccessible(true);//设置true 才能这设置值
        field.set(user, "麻子");

        field = c3.getDeclaredField("address");//获取共有
        field.set(user, "天津");

        System.out.println(user);


    }


    /**
     * 反射获取类 类获取到方法
     *
     * @throws ClassNotFoundException
     */
    @org.junit.Test
    public void t4() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {


        System.out.println("第三种获取反射类");
        Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");

        System.out.println("============反射构造函数，然后实例化对象============");
        User user = (User) c3.getConstructor(int.class, String.class).newInstance(1, "大大");
        User user1 = (User) c3.getConstructor(int.class, String.class).newInstance(1, "大大");

        System.out.println(user == user1);

        System.out.println();
        System.out.println("============getMethods反射获取public方法，包含父类object的方法===========");
        Method[] methods = c3.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }

        System.out.println();
        System.out.println("============getMethod反射获取指定的public方法，包含父类object的方法===========");
        Method m1 = c3.getMethod("add2", int.class);
        System.out.println("方法返回值+10："+m1.invoke(user, 3));


        System.out.println();
        System.out.println("============getDeclaredMethods反射获取public和private方法 只有自己的============");
        Method[] methods1 = c3.getDeclaredMethods();
        for (Method method : methods1) {
            System.out.println(method);
        }


        System.out.println();
        System.out.println("============getDeclaredMethod反射获取public和private方法 只有自己的============");
        Method m2 = c3.getDeclaredMethod("add",int.class);
        m2.setAccessible(true);
        System.out.println("方法返回值+10："+m2.invoke(user1,5));

        m2=c3.getDeclaredMethod("add1",int.class);
        System.out.println("方法返回值+10："+m2.invoke(user1,11));


    }

   

 

      

    
    

    
   

3:反射作用

主要用于框架配置文件加载，反射常常配合工厂模式，代理模式共同作用于框架

假如我们有两个程序员，一个程序员在写程序的时候，需要使用第二个程序员所写的类，但第二个程序员并没完成他所写的类。那么第一个程序员的代码能否通过编译呢？这是不能通过编译的。利用Java反射的机制，就可以让第一个程序员在没有得到第二个程序员所写的类的时候，来完成自身代码的编译。

Java的反射机制它知道类的基本结构，这种对Java类结构探知的能力，我们称为Java类的“自审”。大家都用过Jcreator和eclipse。当我们构建出一个对象的时候，去调用该对象的方法和属性的时候。一按点，编译工具就会自动的把该对象能够使用的所有的方法和属性全部都列出来，供用户进行选择。这就是利用了Java反射的原理，是对我们创建对象的探知、自审。