类加载器、反射机制

• java文件编译成class文件即字节码文件由类加载器负责将其加载到内存
• 类加载用到即加载,不用则不加载
• 类加载过程:加载 – 验证 – 准备 – 解析 – 初始化
• 加载:即通过包名+类名形式 获取这个类,并准备用流的形式进行传输 ,在这个类加载到内存中,会创建一个class对象用于记录成员信息
• 验证:即检查文件中信息是否符合虚拟机规范,有没有安全隐患
• 准备:即初始化静态变量
• 解析:即本类中如果用到其他类,应找到相对应的类,例如:String引用类
• 初始化:即静态变量赋值,以及初始化其他资源
• 类加载器的分类:
• 启动类加载器:虚拟机内置的类加载器
• 平台类加载器:负责加载jdk中一些特殊的模块
• 系统加载器:负责加载用户路径上指定的类库(常用)
• 自定义加载器:自定义
• 双亲委派模型

public class Test01 {
    public static void main(String[] args) throws IOException {
        // 获取加载器演示
        //调用ClassLoader.getSystemClassLoader(),静态方法获取系统类加载器
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();

        //系统类调用getParent()方法,获取上一级加载类即平台加载器
        ClassLoader classLoader1 = classLoader.getParent();

        //平台加载器调用getParent()方法,获取上一级启动类加载器
        ClassLoader classLoader2 = classLoader1.getParent();

         System.out.println("系统类加载器"+classLoader);
         System.out.println("平台类加载器"+classLoader1);
         System.out.println("启动类加载器"+classLoader2);


       // 调用ClassLoader.getSystemClassLoader(),静态方法获取系统类加载器
        ClassLoader classLoader3 = ClassLoader.getSystemClassLoader();

        //调用getResourceAsStream方法指定系统加载器去加载指定资源
        InputStream resourceAsStream = classLoader.getResourceAsStream("ppt.properties");


        //Properties()
        //创建一个无默认值的空属性列表。
        Properties pro = new Properties();

        //load(InputStream inStream)
        //从输入流中读取属性列表（键和元素对）。
        pro.load(resourceAsStream);
        System.out.println(pro);

        //释放资源
        resourceAsStream.close();
                }
                }

• java反射机制:利用反射机制创建对象,即无视任何属性和方法的修饰符
• 获取反射对象三种方式
• class.forname(包名+类名)
• 类名.class
• 创建对象,用其对象名调用getclass方法

public class Test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取class对象的三种方式


        //  方式一: Class.forName(类名+包名)
        Class<?> aClass = Class.forName("com.songzhang.packag1.Classloader.Student");

        //方式二: 通过类名.class方式
        Class<Student> studentClass = Student.class;

        //方式三: 创建对象,在用其对象调用getclass方法
        Student stu = new Student();
        Class<? extends Student> aClass1 = stu.getClass();
    }
}

• 获取构造方法 创建对象 成员变量 成员方法

public class Student {
    private String  name;  //姓名

    private int age;  //年龄

    private char sex = '男';  //性别

    public String height; //身高

    public String money ="1000" ;//钱



    public Student() {
    }

    public Student(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    private Student(String name){
        System.out.println("私有化单个有参构造方法");
    }
    private Student(String name,char sex){
        System.out.println("私有化多个参数构造方法");
    }

    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 char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                ", height='" + height + '\'' +
                ", money='" + money + '\'' +
                '}';
    }

    public String  function(String name){
        System.out.println("有参有返回值");
        return "张三";
    }

    public void function1(String name){
        System.out.println("有参无返回值");
    }

    public void function2(){
        System.out.println("无参无返回值");
    }

    private void function3(){
        System.out.println("私有化无参无返回值");
    }

    private String function4(String name){
        System.out.println("私有化有参有返回值");
        return "李四";
    }
}


public class Test03 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {

        //反射获取构造方法
        //调用getConstructors()方法获取所有的公开构造方法
        methods1();

        //调用getDeclaredConstructors() 方法获取所有的构造方法,包括私有化
         methods2();

        //调用getConstructor()方法获取单个公共的构造方法,形参根据获取构造方法填写,有几个参数写几个,没有则不写
        methods3();

        //调用getDeclaredConstructor方法 可以获取单个构造方法,私有化也能获取
        methods4();

        //根据构造方法创建对象
       //先获取class对象,在获取构造方法,再用构造对象调用newInstance创建对象,参数顺序与构造方法保持一致
        methods5();

        //获取私有化构造方法
        methods6();

       // 获取成员变量

       // getFields()方法获取所有公开成员变量
        MemberMethod1();

       // 调用getDeclaredFields()方法获取所有的成员变量,包括私有化
        MemberMethod2();

       // 调用getField方法获取单个公开的成员变量,参数为变量名
        MemberMethod3();

        //调用getDeclaredField方法获取单个成员变量,包括私有化
        MemberMethod4();

        //调用set get方法进行给成员变量赋值 取值
        //set方法参数为对象类型,所以要创建个对象传进去,参数二为要赋的值
        setmethods();


       // 调用get方法进行取值,如果是私有化成员变量要先取消临时访问,然后传入要访问的对象,返回值为要取的值
        getmethods();

        ///反射获取成员方法
        //调用 getMethods()方法获取所有公共的成员方法
        method1();

       // 调用getDeclaredMethods()返回所有的方法,包括私有化,但不包括继承
        method2();

       // 调用getMethod方法获取公共的方法,参数一为方法名,参数二为方法类型.class
        method3();

        //调用getDeclaredMethod()方法获取私有化成员方法
        method4();

        //调用invoke方法运行
        //创建对象
        invokemethod();
    }

    private static void invokemethod() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
        Class<?> aClass = Class.forName("com.songzhang.packag1.Classloader.Student");

        //获得成员方法
        Method function = aClass.getDeclaredMethod("function", String.class);

        //参数一为对象 ,参数二为传入的参数
        Student Stu = (Student) aClass.newInstance();
        Object invoke = function.invoke(Stu, "王五");
        //运行方法
        System.out.println(invoke);
    }

    private static void method4() throws ClassNotFoundException, NoSuchMethodException {
        Class<?> aClass = Class.forName("com.songzhang.packag1.Classloader.Student");
        Method function3 = aClass.getDeclaredMethod("function3");
        System.out.println(function3);
    }

    private static void method3() throws ClassNotFoundException, NoSuchMethodException {
        Class<?> aClass = Class.forName("com.songzhang.packag1.Classloader.Student");
        Method function1 = aClass.getMethod("function1", String.class);
        System.out.println(function1);
    }

    private static void method2() throws ClassNotFoundException {
        Class<?> aClass = Class.forName("com.songzhang.packag1.Classloader.Student");
        Method[] methods = aClass.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
    }

    private static void method1() throws ClassNotFoundException {
        //获取class对象
        Class<?> aClass = Class.forName("com.songzhang.packag1.Classloader.Student");

        //调用 getMethods()方法获取所有公共的成员方法
        Method[] methods = aClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
    }

    private static void getmethods() throws ClassNotFoundException, NoSuchFieldException, InstantiationException, IllegalAccessException {
        Class<?> aClass = Class.forName("com.songzhang.packag1.Classloader.Student");

        //获取成员变量
        Field sex = aClass.getDeclaredField("sex");

        //get参数为对象类型,即说明从那个对象上取值
        Student Stu = (Student) aClass.newInstance();

        //因为变量私有化,所以要取消临时访问
        sex.setAccessible(true);
        Object o = sex.get(Stu);
        System.out.println(o);
    }

    private static void setmethods() throws ClassNotFoundException, NoSuchFieldException, InstantiationException, IllegalAccessException {
        Class<?> aClass = Class.forName("com.songzhang.packag1.Classloader.Student");

        //获取成员变量
        Field height = aClass.getField("height");


        //set方法传入参数为对象
        //aClass.newInstance()快速创建空参对象
        Student Stu = (Student) aClass.newInstance();
        height.set(Stu,"175");
        System.out.println(Stu);
    }

    private static void MemberMethod4() throws ClassNotFoundException, NoSuchFieldException {
        Class<?> aClass = Class.forName("com.songzhang.packag1.Classloader.Student");
        Field name = aClass.getDeclaredField("name");
        System.out.println(name);
    }

    private static void MemberMethod3() throws ClassNotFoundException, NoSuchFieldException {
        Class<?> aClass = Class.forName("com.songzhang.packag1.Classloader.Student");
        Field money = aClass.getField("money");
        System.out.println(money);
    }

    private static void MemberMethod2() throws ClassNotFoundException {
        Class<?> aClass = Class.forName("com.songzhang.packag1.Classloader.Student");
        Field[] declaredFields = aClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
    }

    private static void MemberMethod1() throws ClassNotFoundException {
        Class<?> aClass = Class.forName("com.songzhang.packag1.Classloader.Student");

        //getFields()方法获取所有公开成员变量
        Field[] fields = aClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
    }

    private static void methods6() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
        //获取class对象
        Class<?> aClass = Class.forName("com.songzhang.packag1.Classloader.Student");

        //获取私有化构造方法
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(String.class);

        //先解除访问权限
        declaredConstructor.setAccessible(true);

        Student Stu1 = (Student) declaredConstructor.newInstance("张三");
        System.out.println(Stu1);
    }

    private static void methods5() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
        //获取class对象
        Class<?> aClass = Class.forName("com.songzhang.packag1.Classloader.Student");

        //获取构造方法
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(String.class, int.class, char.class);

        //调用newInstance创建反射对象,参数与创建反射对象数目一样
        Student Stu = (Student) declaredConstructor.newInstance("张三", 66, '男');
        System.out.println(Stu);
    }

    private static void methods4() throws ClassNotFoundException, NoSuchMethodException {
        Class<?> aClass = Class.forName("com.songzhang.packag1.Classloader.Student");
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(String.class);
        System.out.println(declaredConstructor);
    }

    private static void methods3() throws ClassNotFoundException, NoSuchMethodException {
        Class<?> aClass = Class.forName("com.songzhang.packag1.Classloader.Student");
        Constructor<?> constructor = aClass.getConstructor(String.class,int.class,char.class);
        System.out.println(constructor);
    }

    private static void methods2() throws ClassNotFoundException {
        Class<?> aClass = Class.forName("com.songzhang.packag1.Classloader.Student");
        Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }
    }

    private static void methods1() throws ClassNotFoundException {
        //获取class对象
        Class<?> aClass = Class.forName("com.songzhang.packag1.Classloader.Student");

        //调用getConstructors()方法获取所有的公开构造方法
        Constructor<?>[] constructors = aClass.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }
    }
}