Java反射机制

1. Java反射机制概述

1.1 定义

• Reflection(反射) 动态语言的关键，允许程序在执行的时候借助反射api获得任何类的内部信息，并能直接操作任意对象的内部属性及其方法
• 加载完类以后，在堆内存的方法区中就有了产生了一个Class类型的对象（一个类只有一个Class对象）， 这个对象就包含了完整的类的结构信息。我们可以通过这个类看到类的结构。 这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们称为反射

1.2 Java 反射机制研究及应用

• 在运行时判断任意–个对象所属的类
• 在运行时构造任意一个类的对象
• 在运行时判断任意–个类所具有的成员变量和方法
• 在运行时获取泛型信息
• 在运行时调用任意一个对象的成员变量和方法
• 在运行时处理注解
• 生成动态代理

public class Person {
    private String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person" +
                "name='" + name + '\'' +
                ",age=" + age +
                '}';
    }

    private Person(String name) {
        this.name = name;
    }

    public Person() {
    }

    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 show() {
        System.out.println("hello, I am a pople!");
    }

    private  String showNation(String nation) {
        System.out.println("my nation is :");
        return nation;
    }
}

    public void test02() throws Exception{
        Class clazz = Person.class;

        java.lang.reflect.Constructor cons = clazz.getConstructor(String.class, int.class);

        Object obj = cons.newInstance("Tom", 12);
        Person p = (Person)obj;
        System.out.println(obj.toString());
        //通过反射，调用对象指定的属性，方法
        Field age = clazz.getDeclaredField("age");
        age.set(p,10);

        System.out.println(obj.toString());

        //调用方法
        Method show = clazz.getDeclaredMethod("show");
        show.invoke(p);
        System.out.println("#############################3");
        //通过反射，可以调用Person类的私有接口，比如： 私有的构造器、方法、属性
        Constructor cons1= clazz.getDeclaredConstructor(String.class);
        cons1.setAccessible(true);
        Person p1  = (Person) cons1.newInstance("Jerry");
        System.out.println(p1);

        //调用属性
        Field name = clazz.getDeclaredField("name");
        name.setAccessible(true);
        name.set(p1, "HanMeimei");
        System.out.println(p1);

        //调用私有的方法
         Method showNation = clazz.getDeclaredMethod("showNation", String.class);
         showNation.setAccessible(true);
         String nation = (String)showNation.invoke(p1, "中国"); //相当于p1.showNation("中国")
        System.out.println(nation);
    }

疑问

1. 通过直接new的方式或反射的方式都可以调用公共结构，开发中到底用那个
   答：建议用new
2. 什么时候会使用：反射的方式，
   答：反射的特性: 动态性，
3. 反射机制与面向对象中的封装性是不是矛盾的？如何看待这两个技术
   答：不矛盾。

关于java.lang.Class类的理解

类的加载过程

程序在经过javac.exe命令以后，会生成一个或多个字节码文件（.class结尾），接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码加载到内存中，此过程就称为类的加载，此过程就被称为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类，就做为Class的一个实例

• 换句话说，Class的实例就对应着一个运行时类
• 加载到内存中的运行时类，会缓存一定的时间，在此时间之内，我们可以通过不同的方式来获取运行时类

获取Class的实例的方式（前三种方式需要掌握）

        //方式1： 调用运行时的属性； .class
        Class clazz1 = Person.class;
        System.out.println(clazz1);
        //方式二： 通过运行时类的对象   调用getClass()
        Person p1 = new Person();
        Class clazz2 = p1.getClass();
        System.out.println(clazz2);
        //方式三： 调用Class的静态方法： forName(String classPath)
        Class clazz3 = Class.forName("com.tang.Reflction.Person");
        //clazz3 = Class.forName("java.lang.String");
        System.out.println(clazz3);

        System.out.println(clazz1 == clazz2);           // true
        System.out.println(clazz1 == clazz3);           // true
		//方式四， 使用类加载器： ClassLoader