JAVASE基础模块四十二（反射类的加载类加载器获取一个类的字节码文件对象的三种方式获取构造函数获取私有构造函数反射创建对象

最新推荐文章于 2022-09-20 21:17:57 发布

弎屲

最新推荐文章于 2022-09-20 21:17:57 发布

阅读量314

点赞数

文章标签： java 反射 class

本文链接：https://blog.csdn.net/cx9977/article/details/108243857

版权

JAVASE基础模块四十二（反射类的加载类加载器获取一个类的字节码文件对象的三种方式获取构造函数获取私有构造函数反射创建对象）

类的加载

类的加载概述
1. 当程序要使用某个类的时候如果该类还未加载到内存中系统就会通过加载连接初始化散步来实现对这个类进行初始化
2. 加载：
  - 就是指class文件读入内存并为之创建一个Class对象
  - 任何类被使用时系统都会建立一个CLass对象
3. 连接：
  - 验证：是否有正确的内部结构
  - 准备：负责为类的静态成员分配内存并设置默认初始化值
  - 解析：把类中的符号引用转换为直接引用
  这三个步骤又称为链接阶段
4. 初始化就是我们以前讲过的初始化步骤
类的加载时机
1. 创建类的实例
2. 访问类的静态变量或者为静态变量赋值
3. 调用类的静态方法
4. 使用反射方法来强制创建某个类或借口对应的java.lang.Class对象
5. 初始化某个类的子类
6. 直接使用java.exe命令来运行某个类

类加载器

概述：负责将.Class文件加载到内存中并为之生成对应的Class对象
分类：
1. Bootstrap Classloader 根类加载器
2. Extension Classloader 扩展类加载器
3. System Classloader 系统类加载器

作用

Bootstrap Classloader 根类加载器

引导类加载器 负责Java核心类的加载
比如 System String等 在JDK中JRE的lib目录下rt.jar文件中

Extension Classloader 扩展类加载器

负责JRE的扩展目录中的jar包的加载
在JDK中JRE的lib目录下ext目录

System Classloader 系统类加载器

负责在JVM启动时加载来自java明亮的Class文件
以及classpath环境变量所指定的jar包和类路径

获取一个类的字节码文件对象的三种方式

要使用反射机制要现货区该类的字节码文件对象然后通过该类的字节码文件对象去剖析类的构成以及通过反射去调用类中的属性和功能

方式一：getClass()
方式二：每一个类都有一个.Class属性可以直接获得字节码文件对象
方式三：Class类中的静态方法forName()

package FanShe.X1;

public class Fan {
    public static void main(String[] args) {

        Stu stu = new Stu();
        Class<? extends Stu> aClass = stu.getClass();
        System.out.println(aClass);

        Class<Stu> aClass2 = Stu.class;
        System.out.println(aClass2);
        try {
            Class<?> aClass1 = Class.forName("FanShe.X1");
            System.out.println(aClass1);
            System.out.println(aClass1 == aClass2);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println(aClass == aClass2);
    }
}

class Stu {}

class FanShe.X1.Stu
class FanShe.X1.Stu
class FanShe.X1.Stu
true
true

反射

概述：
1. java反射机制是在运行状态中对于任意一个类都能知道这个类的所有属性和方法
2. 对于任意一个对象都能够调用它的任意一个方法和属性
3. 这种动态获取类的信息以及动态调用对象的方法称为java语言的反射机制
4. 要想解剖一个类必须先获取到该类的字节码文件对象
5. 而解剖使用的就是Class类中的方法所以先要获取到每一个字节码文件对应的class类型的对象
类的构成：成员变量构造方法成员方法
1. 构造方法 Constructor
2. 成员变量 Filed
3. 成员方法 Method

获取构造函数

a.getConstructors() 获取构造函数无法获取私有构造函数

a.getDeclaredConstructors() 获取私有构造函数

import java.lang.reflect.Constructor;

public class GouCheng {
    public static void main(String[] args) {
        try {
            Class<?> a = Class.forName("FanShe.X1.Goo");
            Constructor<?>[] c = a.getConstructors();
            for (Constructor<?> cc : c) {
                System.out.println(cc);
            }
            System.out.println("======================");
            Constructor<?>[] d = a.getDeclaredConstructors();
            for (Constructor<?> dd : d) {
                System.out.println(dd);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class Goo {
    public Goo() { }

    public Goo(String name) { }

    private Goo(String name, int age) { }
}

运行结果：
public FanShe.X1.Goo()
public FanShe.X1.Goo(java.lang.String)
======================
public FanShe.X1.Goo()
public FanShe.X1.Goo(java.lang.String)
private FanShe.X1.Goo(java.lang.String,int)

获取私有构造函数

获取指定的构造方法对象

a.getConstructor() 获取空参的构造方法对象
a.getConstructor(String.class) 获取一个参数的构造方法对象
a.getDeclaredConstructor(String.class, int.class) 获取两个参数的构造方法对象

import java.lang.reflect.Constructor;

public class DanGe {
    public static void main(String[] args) {
       Class<?> a = null;
        try {
            a = Class.forName("FanShe.X1.Go");
            Constructor<?> c = a.getConstructor();
            System.out.println(c);

            Constructor<?> c1 = a.getConstructor(String.class);
            System.out.println(c1);

            Constructor<?> d = a.getDeclaredConstructor(String.class, int.class);
            System.out.println(d);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }

    }
}

class Go {
    public Go() {
        System.out.println("无参构造调用了");
    }

    public Go(String name) {
        System.out.println("一个参数构造调用了");
    }

    private Go(String name, int age) {
        System.out.println("两个参数构造调用了");
    }
}

运行结果：
public FanShe.X1.Go()
public FanShe.X1.Go(java.lang.String)
private FanShe.X1.Go(java.lang.String,int)

反射创建对象

以前创建一个类的对象直接使用new构造方法() S s=new S()
现在反射的方式反射可以调用私有构造方法执行来创建对象

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class ChuangJian {
    public static void main(String[] args) {
        Class<?> a = null;
        try {
            a = Class.forName("FanShe.X1.G");
            Constructor<?> c = a.getConstructor();
            System.out.println(c);
            G o = (G)c.newInstance();
            System.out.println(o);
            Constructor<?> c1 = a.getConstructor(String.class);
            System.out.println(c1);
            Object e = c1.newInstance("却道天凉好个秋");
            System.out.println(e);
            Constructor<?> d = a.getDeclaredConstructor(String.class, int.class);
            System.out.println(d);
            //取消私有的语法检测
            d.setAccessible(true);
            Object y = d.newInstance("一树梨花压海棠", 33);
            System.out.println(y);
        } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InstantiationException | InvocationTargetException e) {
            e.printStackTrace();
        }

    }
}
class G {
    public G() {
        System.out.println("无参构造调用了");
    }
    public G(String name) {
        System.out.println("一个参数构造调用了");
    }
    private G(String name, int age) {
        System.out.println("两个参数构造调用了");
    }
}

运行结果：
public FanShe.X1.G()
无参构造调用了
FanShe.X1.G@6e8cf4c6
public FanShe.X1.G(java.lang.String)
一个参数构造调用了
FanShe.X1.G@12edcd21
private FanShe.X1.G(java.lang.String,int)
两个参数构造调用了
FanShe.X1.G@34c45dca