java反射机制

最新推荐文章于 2024-05-03 16:12:22 发布

保护我方阿遥

最新推荐文章于 2024-05-03 16:12:22 发布

阅读量93

点赞数

文章标签： java 反射

本文链接：https://blog.csdn.net/qq_43117059/article/details/114880723

版权

1、Java反射机制概述

1.1、Java Reflection

Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。
正常方式：需要引入的“包类”名称——>通过new进行实例化——>取得实例化对象。
反射方式：实例化对象——>通过getClass()方法——>得到完整的“包类”名称。

1.2、补充：静态语言 vs 动态语言

动态语言
是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。主要动态语言：Object-C、C#、JavaScript、PHP、Python、Erlang。
静态语言
与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++。
注：Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。Java的动态性让编程的时候更加灵活！

1.3、Java反射机制提供的功能

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

1.4、反射相关的主要API

java.lang.Class:代表一个类。
java.lang.reflect.Method:代表类的方法。
java.lang.reflect.Field:代表类的成员变量。
java.lang.reflect.Constructor:代表类的构造方法。

2、理解Class类并获取Class实例

2.1、反射都能干什么(实例)

创建一个Person类，代码如下：

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

    public Person() {
    }

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

    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;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public void show(){
        System.out.println("你好，我是show方法");
    }
    private String showNation(String nation){
        System.out.println("我的名字是："+nation);
        return nation;
    }
}

在Person类中，name,光有name的构造方法和showNation方法都是私有的，在反射之前，调用属性和方法为：
代码如下：

@Test
    public void test1(){
        //1、创建Person类的对象
        Person p1 = new Person("tom",12);
        //2、通过对象，调用其内部属性，方法
        p1.age = 10;
        System.out.println(p1.toString());
        p1.show();
        //在Person类的外部，不可以通过Person类的实例对象调用其内部私有结构。
        //比如：name、showNation()以及私有的构造器
        //p1.showNation();

如果使用p1调用私有属性或者方法，会出现让创建该属性和方法，可以理解为在Person类外，无法调用Person类的私有属性和方法。
在使用反射后，可以调用Person类的私有属性和方法、构造器等。代码如下：

 @Test
    public void test2() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException, NoSuchFieldException, InstantiationException {
        Class<Person> clazz = Person.class;
        //1、通过反射，创建Person类的对象
        Constructor<Person> cons = clazz.getConstructor(String.class, int.class);
        Person obj = cons.newInstance("Tom", 12);
        System.out.println(obj.toString());
        //2、通过反射，调用对象指定的属性、方法
        //调属性
        Field age = clazz.getDeclaredField("age");
        age.set(obj,10);
        System.out.println(obj.toString());
        //调方法
        Method show = clazz.getDeclaredMethod("show");
        show.invoke(obj);
        System.out.println("*********************");
        //通过反射，可以调用Person类的私有结构的。比如私有属性，私有方法，私有的构造器
        Constructor<Person> cons1 = clazz.getDeclaredConstructor(String.class);
        cons1.setAccessible(true);
        Person p1 = 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 hello = (String) showNation.invoke(p1, "hello");//相当于p1.showNation("hello")
        System.out.println(hello);
    }

运行结果为：
在这里插入图片描述

2.2、理解Class类并获取Class的实例

2.2.1、类的加载过程

程序经过javac.exe命令以后，会生成一个或多个字节码文件(.class结尾)，接着我们使用java.exe命令对摸个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中，此过程就成为类的加载。加载到内存中的类，我们就成为运行时类，就作为Class的一个实例。换句话说，Class的实例就对应这一个运行时类。

2.2.2、获取Class实例

获取Class类的实例(四种方法)

前提：若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高实例：Class clazz= String.class;
前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象实例：Class clazz= “www.atguigu.com”.getClass();
前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException实例：Class clazz= Class.forName(“java.lang.String”);
使用类的加载器ClassLoader
ClassLoadercl = this.getClass().getClassLoader();Class clazz4 = cl.loadClass(“类的全类名”)
代码如下

 @Test
    public void test3(){
       //方式一：调用运行时类的属性：.class
        Class<Person> clazz1 = Person.class;
        System.out.println(clazz1);
        //方拾二：通过运行时类的对象
        Person p1 = new Person();
        Class<? extends Person> clazz2 = p1.getClass();
        System.out.println(clazz2);
        //方式三、调用class的静态方法：forName(String classPath)
        Class<?> clazz3 = null;
        try {
            clazz3 = Class.forName("com.tedu.java.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println(clazz3);
        System.out.println(clazz1==clazz2);
        System.out.println(clazz1==clazz3);
        //方式四、使用类的加载器ClassLoader
        ClassLoader classLoader = ReflectionTest.class.getClassLoader();
        Class<?> clazz4 = null;
        try {
            clazz4 = classLoader.loadClass("com.tedu.java.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println(clazz4);
        System.out.println(clazz1==clazz4);
    }

运行结果：
在这里插入图片描述
注：加载到内存中的运行时类，会缓存一定的时间，在此事件之内，我们可以通过不同的方式来获取运行时类。所以通过不同的方式来获取到的Person类的Class实例是相同的。

2.2.3、哪些类型可以有Class对象？

class：外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类
interface：接口
[]：数组
enum：枚举
annotation：注解@interface
primitivetype：基本数据类型
void

3、类的加载与ClassLoader的理解

3.1、类的加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。

类的加载(Load)：将类的class文件读入内存，并为之创建一个java.lang.Class对象。此过程由类加载器完成。
类的链接(Link)：将类的二进制数据合并到JRE中。
类的初始化(Initialize)：JVM负责对类进行初始化。
拓展：
加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口（即引用地址）。所有需要访问和使用类数据只能通过这个Class对象。这个加载的过程需要类加载器参与。
链接：将Java类的二进制代码合并到JVM的运行状态之中的过程。
a.验证：确保加载的类信息符合JVM规范，例如：以cafe开头，没有安全方面的问题。
b.准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
c.解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。
初始化：
a.执行类构造器()方法的过程。类构造器()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
b.当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
c.虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。

3.2、类加载器的作用

1、类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
2、类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。
3、类加载器作用是用来把类(class)装载进内存的。JVM 规范定义了如下类型的类的加载器。

3.3、类加载器的规范

引导类加载器(BootStrap Classloader)：用C++编写的，是JVM自带的类加载器，负责Java平台核心库，用来装载核心类库。该加载器无法直接获取。
扩展类加载器(Extension Classloader)：负责jre/lib/ext目录下的jar包或java.ext.dirs指定目录下的jar包装入工作库。
系统类加载器(System Classloader)：负责java –classpath或–D java.class.path所指的目录下的类与jar包装入工作，是最常用的加载器。
注意：自顶向下尝试加载类自底向上检查类是否已加载。

3.3、实例

 @Test
    public void test1(){
        //对于自定义类，使用系统类加载器进行加载
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        System.out.println(classLoader);
        //调用系统类加载器的getParent():获取扩展类加载器
        ClassLoader classLoader1 = classLoader.getParent();
        System.out.println(classLoader1);
        //调用扩展类加载器的getParent():无法获取引导类加载器
        //引导类加载器主要负责加载java的核心类库，无法加载自定义类的
        ClassLoader classLoader2 = classLoader1.getParent();
        System.out.println(classLoader2);
        //因为String为java的核心类库，所以无法加载引导类
        ClassLoader classLoader3 = String.class.getClassLoader();
        System.out.println(classLoader3);
    }

运行结果：
在这里插入图片描述

3.4、使用ClassLoader读取配置文件

在当前module中的src目录下创建jdbc.properties文件，如图所示：
在这里插入图片描述使用ClassLoader类加载器读取该文件中的内容：

/**
     * properties:用于读取配置文件
     */
    @Test
    public void test2() {
        Properties pros = new Properties();
        //此时当前文件目录默认为当前module下
        //读取配置文件的方式一：使用普通流读取配置文件
        /*FileInputStream fis = null;
        try {
            fis = new FileInputStream("jdbc.properties");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        try {
            pros.load(fis);
        } catch (IOException e) {
            e.printStackTrace();
        }*/
        //读取配置文件的方式二：使用ClassLoader读取配置文件
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        InputStream rs = classLoader.getResourceAsStream("jdbc.properties");
        try {
            pros.load(rs);
        } catch (IOException e) {
            e.printStackTrace();
        }
        String user = pros.getProperty("user");
        String password = pros.getProperty("password");
        System.out.println(user+","+password);
    }

运行结果：
在这里插入图片描述注意：在使用普通流读取时，默认读取的路径为当前module下，在使用类加载器读取时，默认的读取路径为当前module下的src路径下。

4、创建运行时类的对象

4.1、创建类的对象

调用Class对象的newInstance()方法！！！
要求：

类必须有一个无参数的构造器。
类的构造器的访问权限需要足够。

4.2、创建类的方法

根据全类名获取对应的Class对象。
tring name = “com.tedu.java.Person";
Class clazz= null;
clazz= Class.forName(name);
调用指定参数结构的构造器，生成Constructor的实例。
Constructor con = clazz.getConstructor(String.class,Integer.class);
通过Constructor的实例创建对应类的对象，并初始化类属性。
Person p2 = (Person) con.newInstance(“Peter”,20);
System.out.println(p2);

4.3、实例

创建一个Person类，获取运行时类的对象

 @Test
    public void test1() {
        Class<Person> clazz = Person.class;
        Person obj = null;
        try {
            /**
             * newInstance():调用此方法，创建对应的运行时类的对象
             * 内部调用的是运行时类的空参构造器
             * 要想此方法正常的创建运行时类的对象：要求：
             * 1、运行时类必须提供空参构造器。
             * 2、空参的构造器的访问权限必须足够。通常，设置为public。
             *
             * 通常在javabean中要求提供一个public的空参构造器，原因：
             * 1、便于通过反射，创建运行时类的对象。
             * 2、便于子类继承此运行时类，默认调用super()时，保证父类有此构造器。
             */
            obj = clazz.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        System.out.println(obj);
    }

运行结果：

在这里插入图片描述

5、获取运行时类的完整结构

5.1、创建实例类，以及父类，实现的接口，自定义注解

创建Person类

@MyAnnotation
public class Person extends Creature<String> implements Comparable<String>,MyInterface{
    private String name;
    int age;
    public int id;

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

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @MyAnnotation
    private String show(String nation) throws NoSuchFieldException{
        System.out.println("我的国籍是:"+nation);
        return nation;
    }

    public String display(String instests){
        return instests;
    }


    @Override
    public void info() {
        System.out.println("我是一个人");
    }

    @Override
    public int compareTo(String o) {
        return 0;
    }
}

创建父类Creature

public class Creature<T> implements Serializable {
    private char gender;
    public double weight;

    private void breath(){
        System.out.println("生物呼吸");
    }
    private void eat(){
        System.out.println("生物吃东西");
    }
}

创建Person类实现的MyInterface接口

public interface MyInterface {
    void info();
}

创建自定义注解MyAnnotation

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value() default "hello";
}

5.2、获取运行时类的属性

getFields():获取当前运行时类以及父类中声明为public访问权限的属性。
getDeclaredFields():获取当前运行时类中声明的所有的属性，不包含父类中的属性。

@Test
    public void test1(){
        Class<Person> clazz = Person.class;
        //获取属性结构
        //getFields():获取当前运行时类以及父类中声明为public访问权限的属性
        Field[] fields = clazz.getFields();
        for (Field fid :fields){
            System.out.println(fid);
        }
        System.out.println("*********************");

        //getDeclaredFields():获取当前运行时类中声明的所有的属性，不包含父类中的属性。
        Field[] dfield = clazz.getDeclaredFields();
        for (Field fids : dfield){
            System.out.println(fids);
        }
    }

运行结果：
在这里插入图片描述

5.3、获取运行时类的权限修饰符数据类型变量名

权限修饰符：getModifiers();
数据类型：getType()；
变量名：getName()

 	@Test
    public void test2(){
        Class<Person> clazz = Person.class;
        Field[] dfield = clazz.getDeclaredFields();
        for (Field fids : dfield){
            //1.权限修饰符
            int modifiers = fids.getModifiers();
            System.out.print(Modifier.toString(modifiers)+"\t");
            //2.数据类型
            Class<?> type = fids.getType();
            System.out.print(type.getName()+"\t");
            //3.变量名
            String fName = fids.getName();
            System.out.print(fName);
            System.out.println();
        }
    }

运行结果：
在这里插入图片描述

5.4、获取运行时类的方法结构

getMethods():获取当前运行时类机器所有父类中声明为public权限的方法
getDeclaredMethods():获取当前运行时类中声明的所有方法(不包含父类中的方法)

 @Test
    public void test1(){
        Class<Person> clazz = Person.class;
        //getMethods():获取当前运行时类机器所有父类中声明为public权限的方法
        Method[] methods = clazz.getMethods();
        for (Method m : methods){
            System.out.println(m);
        }
        System.out.println("**********************");
        //getDeclaredMethods():获取当前运行时类中声明的所有方法(不包含父类中的方法)
        Method[] dMethod = clazz.getDeclaredMethods();
        for (Method dm : dMethod){
            System.out.println(dm);
        }
    }

运行结果：
在这里插入图片描述

5.5、获取运行时类的权限修饰符，返回值类型方法名(参数类型1，参数类型二,…) throws{}

获取方法的注解:getAnnotations();
权限修饰符:Modifier.toString(dm.getModifiers());
返回值类型:dm.getReturnType().getName();
方法名：getName()；
形参列表：getParameterTypes();
抛出异常：getExceptionTypes();
代码如下：

 @Test
    public void test2(){
        Class<Person> clazz = Person.class;
        Method[] dMethod = clazz.getDeclaredMethods();
        for (Method dm : dMethod){
            //1、获取方法的注解
            Annotation[] annos = dm.getAnnotations();
            for (Annotation a : annos){
                System.out.println(a);
            }
            //2、权限修饰符
            System.out.print(Modifier.toString(dm.getModifiers())+"\t");
            //3、返回值类型
            System.out.print(dm.getReturnType().getName()+"\t");
            //4、方法名
            System.out.print(dm.getName());
            System.out.print("(");
            //5、形参列表
            Class<?>[] parameterTypes = dm.getParameterTypes();
            if(!(parameterTypes==null&&parameterTypes.length==0)){
                for(int i=0;i<parameterTypes.length;i++){
                    if(i==parameterTypes.length-1){
                        System.out.print(parameterTypes[i].getName()+"args_"+i);
                        break;
                    }
                    System.out.print(parameterTypes[i].getName()+"args_"+i+",");
                }
            }
            System.out.print(")");
            //6、抛出异常
            Class<?>[] exceptionTypes = dm.getExceptionTypes();
            if(exceptionTypes.length>0){
                System.out.print(" throws ");
                for(int i=0;i<exceptionTypes.length;i++){
                    if(i==exceptionTypes.length-1){
                        System.out.print(exceptionTypes[i].getName());
                        break;
                    }
                    System.out.print(exceptionTypes[i].getName()+",");
                }
            }
            System.out.println();
        }
    }

运行结果：
在这里插入图片描述

5.6、获取运行时类的其他结构

获取构造器结构：getConstructors();
获取当前运行时类中声明的所有的构造器：getDeclaredConstructors();

@Test
    public void test1(){
        Class<Person> clazz = Person.class;
        //获取当前运行时类中的声明为public的构造器
        Constructor<?>[] constructors = clazz.getConstructors();
        for (Constructor cs : constructors){
            System.out.println(cs);
        }
        System.out.println("***********************");
        //getDeclaredConstructors():获取当前运行时类中生命的所有的构造器
        Constructor<?>[] declaredConstructors = clazz.getDeclaredConstructors();
        for (Constructor css : declaredConstructors){
            System.out.println(css);
        }
    }

运行结果：
在这里插入图片描述
3. 获取运行时类的父类：getSuperclass();

@Test
    public void test2(){
        Class<Person> clazz = Person.class;
        //getSuperclass():获取运行时类的父类
        Class<? super Person> superclass = clazz.getSuperclass();
        System.out.println(superclass);
    }

运行结果：
在这里插入图片描述 4. 获取运行时类的带泛型的父类：getGenericSuperclass();

 @Test
    public void test3(){
        Class<Person> clazz = Person.class;
        //getGenericSuperclass():获取运行时类带泛型的父类
        Type genericSuperclass = clazz.getGenericSuperclass();
        System.out.println(genericSuperclass);
    }

运行结果：
在这里插入图片描述 5. 获取运行时类的带泛型的父类的泛型：getGenericSuperclass();

 @Test
    public void test4(){
        Class<Person> clazz = Person.class;
        //getGenericSuperclass():获取运行时类带泛型的父类的泛型
        ParameterizedType parameterizedType = (ParameterizedType) clazz.getGenericSuperclass();
        //获取泛型类型
        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
        System.out.println(actualTypeArguments[0].getTypeName());
    }

运行结果：
在这里插入图片描述
6. 获取运行时类实现的接口：getInterfaces();

    @Test
    public void test5(){
        Class<Person> clazz = Person.class;
        //getInterface():获取运行时类所实现的接口
        Class<?>[] interfaces = clazz.getInterfaces();
        for (Class in : interfaces){
            System.out.println(in);
        }
        System.out.println();
        Class<?>[] interfaces1 = clazz.getSuperclass().getInterfaces();
        for (Class in1 : interfaces1){
            System.out.println(in1);
        }
    }

运行结果：
在这里插入图片描述
7. 获取运行时类所在的包:getPackage();

 @Test
    public void test6(){
        Class<Person> clazz = Person.class;
        Package aPackage = clazz.getPackage();
        System.out.println(aPackage);
    }

运行结果：
在这里插入图片描述
8. 获取运行时类声明的注解：getAnnotations();

 @Test
    public void test7(){
        Class<Person> clazz = Person.class;
        Annotation[] annotations = clazz.getAnnotations();
        for (Annotation annos : annotations){
            System.out.println(annos);
        }
    }

运行结果：
在这里插入图片描述

6、调用运行时类的指定结构

6.1、调用运行时类的属性

以上述的Person类为例

@Test
    public void testField1(){
        try {
            Class<Person> clazz = Person.class;
            //创建运行时类的对象
            Person p = clazz.newInstance();
            //getDeclaredField(String fieldName):获取运行时类中指定变量名的属性
            Field name = clazz.getDeclaredField("name");
            //2、保证当前属性是可访问的
            name.setAccessible(true);
            /**
            * 设置当前属性的值
         	* set():参数1：指明设置哪个对象的水性
            *       参数2：将此属性值设置为多少
            */
            name.set(p,"Tom");
            /**
            * get():参数1：获取哪个对象的当前属性值
            */
            System.out.println(name.get(p));
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
    }

运行结果为：
在这里插入图片描述

6.2、调用运行时类指定的方法

以上述的Person类为例，

@MyAnnotation
    private String show(String nation) throws NoSuchFieldException{
        System.out.println("我的国籍是:"+nation);
        return nation;
    }

调用该方法：

@Test
    public void testMethod(){
        try {
            Class<Person> clazz = Person.class;
            //创建运行时类的对象
            Person p = clazz.newInstance();
            //获取指定的某个方法
            /**
             * getDeclaredMethod():参数1：指明获取的方法的名称
             * 参数2：指明获取的方法的形参列表
             */
            Method show = clazz.getDeclaredMethod("show", String.class);
            /**
             * invoke():参数1：方法的调用者
             * 参数2：给方法形参赋值实参
             */
            show.setAccessible(true);
            Object chn = show.invoke(p, "CHN");
            System.out.println(chn);
            System.out.println("*********如何调用静态方法*********");
            //private static void showDesc()
            /**
             * 如果调用的运行时类没有返回值，则invoke()返回null
             */
            Method showDesc = clazz.getDeclaredMethod("showDesc");
            showDesc.setAccessible(true);
            Object invoke = showDesc.invoke(Person.class);
            System.out.println(invoke);

        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

在Person类中添加一个静态方法：

private static void showDesc(){
        System.out.println("我是一个静态的方法");
    }

运行结果为：
在这里插入图片描述

6.3、调用运行时类中指定的构造器

以Person为例，调用该构造器

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

@Test
    public void testConstructor(){
        Person tom = null;
        try {
            Class<Person> clazz = Person.class;
            //private Person(String name)
            //1、获取指定的构造器
            //getDeclaredConstructor():参数:指明构造器的参数列表
            Constructor<Person> declaredConstructor = clazz.getDeclaredConstructor(String.class);
            //2、保证此结构器是可访问的
            declaredConstructor.setAccessible(true);
            //3、调用此构造器创建运行时类的对象
            tom = declaredConstructor.newInstance("Tom");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        System.out.println(tom);
    }

运行结果：
在这里插入图片描述

保护我方阿遥

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java反射机制

1、Java反射机制概述1.1、Java ReflectionReflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。正常方式：需要引入的“包
复制链接

扫一扫