java反射

类加载器

类的加载时机
1.创建该类的对象时。
2.使用该类的静态成员时。
3.创建该类的子类对象时。
4.利用反射获取该类的Class类型的对象时。
5.java命令执行这个程序。
类加载器：
类加载器是负责加载类的的对象，将class文件（硬盘）加载到内存生成Class对象。
类加载器的分类：
三个类加载器之间不存在继承关系。可以通过get.parent获取父加载器
BootstrapClassLoader 根类加载器：负责加载核心类
ExtClassLoader 扩展类加载器：负责jre扩展目录中jar包的加载。
AppClassLoader 系统类加载器/应用类加载器：自己定义的类和第三方jar包中的类。
类的加载机制：
全盘负责委托机制: 谁用谁就优先加载
public class Person {
String name;
DNSNameService dns;
}
Person 应该由AppClassLoader加载
Person内部 使用 了 String ,也应该由 AppClassLoader 加载
先问 ExtClassLoader 负责加载 String 吗? 不负责
再问 BootstrapClassLoade r负责加载 String 吗? 负责
Person内部 使用 了 DNSNameService ,也应该由 AppClassLoader加载
先问 ExtClassLoader 负责加载 DNSNameService 吗? 负责
获取类加载器：

public class hello {
    public static void main(String[] args) {
        //获取类加载器类名.class.getClassLoader
        //此方法还可以获取其他两种类加载器
        ClassLoader c = hello.class.getClassLoader();
        System.out.println(c);
    }
}

java通过Class类专门处理.class文件也是有对象的，我们无法自己创建对象，jvm创建Class对象。

反射的介绍

1.当第一次使用类的信息时，该类的.class文件会被加载到内存中的方区中。
2.类加载器会为该.class文件创建一个Class类型的对象，该对象会存储再堆内存中，该对象指向.class文件
3.一个类的.class文件只能被加载一次，所以对应的Class类型的对象也就只有一个。
4.任意类型的都有对应的Class类型的对象。
反射
同过Class对象操作对应的.class文件，获取成员变量/成员方法/构造方法，并执行。

获取Class对象的三种方式

public class Test {
    //获取Class对象
    public static void main(String[] args) throws ClassNotFoundException {
        //对象.getClass方式
        person p1 = new person();
        Class p = p1.getClass();
        System.out.println(p);
        //类名.class的方式
        Class p2 = person.class;
        System.out.println(p2);
        //Class.forName("全类名")
        Class p3 = Class.forName("com.jinkai.reffict.person");
        System.out.println(p3);
        //普通类型
        Class i = int.class;
        System.out.println(i);
        //获取类型，不包含包名
        String simpleName = p3.getSimpleName();
        System.out.println(simpleName);
        //获取类名，包含包名
        String name = p3.getName();
        System.out.println(name);
    }
}

Class对象获取构造方法

public class Test {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //class对象获取构造方法
        Class<?> person = Class.forName("com.jinkai.reffict.person");
        //获取所有的构造方法
        Constructor<?>[] constructors = person.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }
        //获取空参构造
        Constructor<?> constructor = person.getConstructor();
        System.out.println(constructor);
        //获取有参构造方法
        Constructor<?> constructor1 = person.getConstructor(String.class, int.class);
        System.out.println(constructor1);
        //获取私有的构造方法
        Constructor<?> declaredConstructor = person.getDeclaredConstructor(int.class);
        System.out.println(declaredConstructor);
    }
}

Class对象获取构造方法并执行

public class Test {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //class对象获取构造方法
        Class<?> person = Class.forName("com.jinkai.reffict.person");
        //获取空参构造
        Constructor<?> constructor = person.getConstructor();
        person o = (com.jinkai.reffict.person) constructor.newInstance();
        System.out.println(o);
        //获取有参构造方法
        Constructor<?> constructor1 = person.getConstructor(String.class, int.class);
        person i = (com.jinkai.reffict.person) constructor1.newInstance("zhangsan", 14);
        System.out.println(i);
        //获取私有的构造方法
        Constructor<?> declaredConstructor = person.getDeclaredConstructor(int.class);
        //取消java语言的访问检查
        declaredConstructor.setAccessible(true);
        person y = (com.jinkai.reffict.person) declaredConstructor.newInstance(15);
        System.out.println(y);
    }
}

Class类型对象获取method方法

public class Test {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //class对象获取构造方法
        Class<?> person = Class.forName("com.jinkai.reffict.person");
        //获取所有方法
        Method[] methods = person.getMethods();
        for (Method method : methods) {
            //System.out.println(method);
        }
        //获取指定名称的方法共有和私有都可
        Method getName = person.getDeclaredMethod("name",String.class);
        System.out.println(getName);
    }
}

反射获取方法并执行

public class Test {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<?> clazz = Class.forName("com.jinkai.reffict.person");
        //反射获取对象
        Constructor<?> constructor = clazz.getConstructor();
        person p = (person) constructor.newInstance();
        //反射获取方法
        Method name = clazz.getMethod("name");
        System.out.println(name.invoke(p));
        Method setName = clazz.getMethod("setName", String.class);
        Object lisi = setName.invoke(p,"lisi");
        System.out.println(lisi);
    }
}

再私有方法时需要加上setAccessible(true)检查。