类加载&反射机制

水深无声 2024-04-01 19:14 109阅读 0赞

**目录**

类加载

类的执行过程

类初始化的步骤

类的初始化时机

类加载器

类加载器的作用

获取Class对象的三种方法

反射机制

反射API

Class类的常用方法：

获取属性（Field-getName()）

获取方法（Method-getName()）

获取构造方法

核心反射API：Class类

--------------------

### 类加载 ###

当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过类的加载、类的连接、类的初始化这三个步骤来对类进行初始化。如果不出现意外情况，JVM将会连续完成这三个步骤，所以有时也罢这三个步骤称为类加载 或者类的初始化。

**类的加载**

*  就是指将class文件读入内存，并为之创建一个java..lang.Class对象
 *  如任何类被使用时，系统都会为之创建一个java.lang.Class对象![ccf67848dd1e448a8aed051109f48b08.png][]

**此处的Class是一个实实在在的类， 不是一个关键词class**

**类的连接**

*  验证阶段：用于检验被加载的类是否有正确的内部结构，并和其他类协调一致
 *  准备阶段：负责为类的类变量分配内存，并设置默认初始化值
 *  解析阶段：将类的二进制数据中的符号应用替换为直接引用

**类的初始化**

*  在该阶段，主要就是类变量进行初始化

#### 类的执行过程 ####

![8d140bc05a38419bb3ebfa374193e04b.png][]

#### 类初始化的步骤 ####

1.  假如类还未被加载和连接，则程序先加载并连接该类
2.  假如该类的直接父类还未被初始化，则先初始化其直接父类
3.  假如类中有初始化语句，则系统一次执行这些初始化语句

**在执行第二个步骤的时候，系统对直接父类的初始化步骤也遵循初始化步骤1-3**

#### 类的初始化时机 ####

*  创建类的实例
 *  调用类的类方法
 *  访问类或者接口的类变量，或者为该类变量赋值
 *  使用反射方式来强制创建某个类或者接口对应的java.lang.Class对象
 *  初始化某个类的子类
 *  直接使用java.exe命令来运行某个主类

### 类加载器 ###

#### 类加载器的作用 ####

*  负责将.class文件加载到内存中，并为之生成对应的java.lang.Class对象

### 获取Class对象的三种方法 ###

1.  使用Class类中的静态方法forName（）
2.  调用对象的getClass（）方法
3.  调用类的class属性

public class Student {
        public static void main(String[] args) {
    
            //1.使用Class类中的静态方法forName（）
            try {
                Class c = Class.forName("java1116_xia.Student");
                System.out.println(c.getName());
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
    
            //2.调用对象的getClass（）方法
            Student student = new Student();
            Class c2 = student.getClass();
            System.out.println(c2);
    
            //3.调用类的class属性
            Class<Student> c3 = Student.class;
            System.out.println(c3);
        }
    }

输出结果：.

![fe05a9ee583246d59100c9198502dbf2.png][]

### 反射机制 ###

**反射机制：**java的反射机制是java的特性之一，反射机制是构建框架技术的基础，灵活掌握java反射机制，对学习框架技术将有很大的帮助。

Java反射机制是指在运行状态中，动态获取信息以及动态调用对象方法放入功能。

**Java反射有3个动态性质**

*  运行时生成对象实例
 *  运行期间调用方法
 *  运行时更改属性

#### 反射API ####

*  Class类：反射的核心类，可获取类的属性，方法等信息，生成类的实例
 *  Field类：表示类的成员变量，可用来获取和设置类的属性值
 *  Method类：表示类的方法，可用来获取类中的方法信息或者执行方法
 *  Constructor类：表示类的构造方法

### Class类的常用方法： ###

#### 获取属性（Field-getName()） ####

*  getFields() -所有可访问的公共字段
 *  getDeclaredFields() -所有字段
 *  getField(String name) -返回一个特定的公共字段对象

#### 获取方法（Method-getName()） ####

*  getMethods()-所有公共方法，包括从超类和超接口继承的声明
 *  getDeclaredMethods() -所有方法，包括公共，保护，默认（包）访问和私有方法，但不包括继承的方法
 *  getMethod(String name, Class\[\] parameterTypes)-返回一个方法对象

#### **获取构造方法** ####

*  getConstructor(Class\[\] parameterTypes)-返回一个构造方法对象
 *  通过Constructor-newInstance(Object\[\] initargs)可生成类的实例
 *  通过Method-invoke(Object obj,Object\[\] args),可在具有指定参数的方法对象上调用此方法对象表示的基础方法

public class Person {
        private String name;
        private Integer age;
        public String grade;
        Double score;
        protected Boolean tag;
    
    
        public Person() {
        }
    
        public Person(String name, Integer age, String grade) {
            this.name = name;
            this.age = age;
            this.grade = grade;
    
        }
    
        public Person(String name, Integer age, Double score) {
            this.name = name;
            this.age = age;
            this.score = score;
    
        }
    
    
        /**
         * 获取
         *
         * @return name
         */
        public String getName() {
            return name;
        }
    
        /**
         * 设置
         *
         * @param name
         */
        public void setName(String name) {
            this.name = name;
        }
    
        /**
         * 获取
         *
         * @return age
         */
        public Integer getAge() {
            return age;
        }
    
        /**
         * 设置
         *
         * @param age
         */
        public void setAge(Integer age) {
            this.age = age;
        }
    
        /**
         * 获取
         *
         * @return grade
         */
        public String getGrade() {
            return grade;
        }
    
        /**
         * 设置
         *
         * @param grade
         */
        public void setGrade(String grade) {
            this.grade = grade;
        }
    
        /**
         * 获取
         *
         * @return score
         */
        public Double getScore() {
            return score;
        }
    
        /**
         * 设置
         *
         * @param score
         */
        public void setScore(Double score) {
            this.score = score;
        }
    
        /**
         * 获取
         *
         * @return tag
         */
        public boolean isTag() {
            return tag;
        }
    
        /**
         * 设置
         *
         * @param tag
         */
        public void setTag(boolean tag) {
            this.tag = tag;
        }
        
        public void showMsg() {
            System.out.println(getName() + "," + getAge() + "," + getGrade());
        }
    
        public String toString() {
            return "Person{name = " + name + ", age = " + age + ", grade = " + grade + ", score = " + score + ", tag = " + tag + "}";
        }
    }

import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    
    public class PersonTest {
        public static void main(String[] args) {
            Class c = null;
            try {
                c = Class.forName("java1116_xia.Person");
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
    
            Field[] fields = c.getFields();//只能获取到public
            for (int i = 0; i < fields.length; i++) {
                Field field = fields[i];
                System.out.println(field.getName() + " " + field.getType());
            }
    
            System.out.println("--------------------------------------------------------------------------------------------");
    
            fields = c.getDeclaredFields();
            for (int i = 0; i < fields.length; i++) {
                Field field = fields[i];
                System.out.println(field.getName() + " " + field.getType() + " " + field.getModifiers());
            }
    
            System.out.println("--------------------------------------------------------------------------------------------");
    
            try {
    //            Field grade = c.getField("grade");
                Field grade = c.getDeclaredField("name");
                System.out.println(grade.getName() + " " + grade.getType());
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            }
    
            System.out.println("--------------------------------------------------------------------------------------------");
    
    //        Method[] methods = c.getMethods();
            Method[] methods = c.getDeclaredMethods();
            for (Method method : methods) {
                System.out.println(method.getName()+","+method.isBridge()+","+method.isVarArgs());
            }
            System.out.println("--------------------------------------------------------------------------------------------");
    
            //获取构造方法对象
            //获取Person无参构造方法的对象
            try {
                Constructor constructor = c.getConstructor();
                System.out.println(constructor.getName());
                //获取带参数的构造 方法 的对象
                Constructor constructor1 = null;
    
                constructor1 = c.getConstructor(new Class[]{String.class, Integer.class, String.class});
                System.out.println(constructor1.getName());
                //根据构造方法对象完成类对象的实例化
                Object obj = constructor.newInstance();
                System.out.println(obj);
                if (obj instanceof Person){
                    System.out.println("yes");
                }else {
                    System.out.println("no");
                }
                Object obj1 = constructor1.newInstance(new Object[]{"张三",28,"大班"});
                System.out.println(obj1);
    
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (InvocationTargetException ex) {
                ex.printStackTrace();
            } catch (InstantiationException ex) {
                ex.printStackTrace();
            } catch (IllegalAccessException ex) {
                ex.printStackTrace();
            }
    
            System.out.println("--------------------------------------------------------------------------------------------");
            //获取构造方法对象
            //获取Person无参构造方法的对象
            try {
                Constructor constructor = c.getConstructor();
                System.out.println(constructor.getName());
                //获取带参数的构造 方法 的对象
                Constructor constructor1 = null;
                constructor1 = c.getConstructor(new Class[]{String.class, Integer.class, Double.class});
                System.out.println(constructor1.getName());
                //根据构造方法对象完成类对象的实例化
                Object obj = constructor.newInstance();
                System.out.println(obj);
                /*if (obj instanceof Person){
                    System.out.println("yes");
                }else {
                    System.out.println("no");
                }*/
                Object obj1 = constructor1.newInstance(new Object[]{"张三",28,90.0});
                System.out.println(obj1);
    
                //"showMsg"
                Method showMsg = c.getMethod("showMsg");
                showMsg.invoke(obj1,null);
                showMsg.invoke(obj,null);
    
                Method getName = c.getMethod("getName");
                System.out.println(getName.invoke(obj1, null));
    
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (InvocationTargetException ex) {
                ex.printStackTrace();
            } catch (InstantiationException ex) {
                ex.printStackTrace();
            } catch (IllegalAccessException ex) {
                ex.printStackTrace();
            }
    
    
        }
    }

输出结果：![717f1f650d6047e78e61e2f483c71d5a.png][]

#### 核心反射API：Class类 ####

**通过Class类的对象可以**

*  获取类的属性、方法
 *  生成类的实例
 *  调用实例的方法、属性

**反射** :通过操作Class类的对象

*  实现对类的操作
 *  实现对对象的操作

![ef9567ee44574a9d912e19b9e0925eed.png][]

![56d38b929d8140efb8ba80bd4d8b8fe9.png][]

[ccf67848dd1e448a8aed051109f48b08.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/f1bbc1b6c8d048498f677b5f5a2041c8.png
[8d140bc05a38419bb3ebfa374193e04b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/2b6fb416dc03478d8d3b27eb30b987bc.png
[fe05a9ee583246d59100c9198502dbf2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/043c357286c145158f157ea1fabc3264.png
[717f1f650d6047e78e61e2f483c71d5a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/2ba4b827f8ac49c7a0b5f84b2694cfc6.png
[ef9567ee44574a9d912e19b9e0925eed.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/b11e503e34d042668de49322c922012e.png
[56d38b929d8140efb8ba80bd4d8b8fe9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/2b0bcfaff34c4820973934a6c39f48c3.png