java 反射

鱼尾巴选手

于 2022-09-27 11:11:34 发布

阅读量133

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_62918925/article/details/127067973

版权

反射

1. 引入反射问题

一个需求：

（1）根据配置文件re.properties指定信息，创建Cat对象并调用方法hi
classullpath= com.hspedu.Cat
method=hi

？？？

（2）这样的需求在学习框架时特别多，即通过外部文件配置，在不修改源码情况下，来控制程序，也符合设计模式的ocp原则（开闭原则：不修改源码，来扩容功能）

import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * 反射问题的引入
 */

public class ReflectionQuestion {
    public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        // 根据配置文件re.properties 指定信息，创建Cat对象并调用方法hi
        // 1. 传统方式
//        Cat cat = new Cat();
//        cat.hi();

        // 2.
        // 使用Properties类，可以读写配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("BasicGrammar\\src\\re.properties"));
        String classfullpath = properties.getProperty("classfullpath");
        String methodName = properties.getProperty("method");
        System.out.println("classfullpath= " + classfullpath);  // classfullpath= com.reflection
        System.out.println("methodName= " + methodName);    // methodName= hi

        // 创建对象，传统的方法，错误
//        new classfullpath();

        // 使用反射机制解决
        // (1) 加载类
        Class cls = Class.forName(classfullpath);    // Class是一个类
        // (2) 通过cls 得到加载的类 com.reflection.Cat 的对象实例
        Object o = cls.newInstance();
        System.out.println("o的运行类型：" + o.getClass());
        // (3) 得到加载的类com.reflection.Cat 的methodName 的方法对象
        Method method1 = cls.getMethod(methodName);
        // (4) 通过method1 调用方法
        method1.invoke(o);  // 反射机制    方法.invoke(对象)

    }
}

2. 反射机制

反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息（比如成员变量，构造器，成员方法等等），并能操作对象的属性及方法。反射在设计模式和框架底层都会用到。
加载完类之后，在堆中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，形象的称之为：反射。

2.1 反射机制原理图

原理图

反射机制可以完成：

在运行时判断任意一个对象所属的类；
在运行时构造任意个类的对象；
在运行时得到任意一个类所具有的成员变量和方法；
在运行时调用任意一个对象的成员变量和方法；
生成动态代理；

2.2 反射相关的主要类

类	说明
java.lang.Class	代表一个类，Class对象表示某个类加载后在堆中的对象
java.lang.reflect.Method	代表类的方法，Method对象表示某个类的方法
java.lang.reflect.Field	代表类的成员变量，Field对象表示某个类的成员变量
java.lang.reflect.Constructor	代表类的构造方法，Constructor对象表示构造器

Field和Constructor演示：

import java.io.FileInputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Properties;

public class Reflection01 {
    public static void main(String[] args) throws Exception {

        // 使用Properties类读写配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("BasicGrammar\\src\\re.properties"));
        String classfullpath = properties.getProperty("classfullpath");
        String methodName = properties.getProperty("method");

        // (1) 加载类
        Class cls = Class.forName(classfullpath);    // Class是一个类
        // (2) 通过cls 得到加载的类 com.reflection.Cat 的对象实例
        Object o = cls.newInstance();
        System.out.println("o的运行类型：" + o.getClass());
        // (3) 得到加载的类com.reflection.Cat 的methodName 的方法对象
        Method method1 = cls.getMethod(methodName);
        // (4) 通过method1 调用方法
        method1.invoke(o);  // 反射机制    方法.invoke(对象)


        // java.lang.reflect.Field
        // 得到name字段
        // getField() 不能得到私有的字段
        Field ageField = cls.getField("age");
        System.out.println(ageField.get(o));

        // java.lang.reflect.Constructor
        // 获取构造器
        // getConstructor() 括号里可以指定构造器参数类型
        Constructor constructor1 = cls.getConstructor();    // 无参构造器
        System.out.println(constructor1);
        Constructor constructor2 = cls.getConstructor(String.class);    // 带参数的构造器
        System.out.println(constructor2);

    }
}

运行的结果：

2.3 反射的优缺点

优点：可以动态的创建和使用对象（也是框架底层核心），使用灵活，没有反射机制，框架技术就失去底层支撑。
缺点：使用反射基本是解释执行，对执行速度有影响。

import java.lang.reflect.Method;

/**
 * 测试反射调用的性能，和优化方案
 */

public class Reflection02 {
    public static void main(String[] args) throws Exception {
        m1();
        m2();
    }

    // 传统方法调用hi
    public static void m1() {
        Cat cat = new Cat();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 90000000; i++) {
            cat.hi();
        }
        long end = System.currentTimeMillis();
        System.out.println("m1() 耗时：" + (end - start));

    }

    // 反射机制调用方法hi
    public static void m2() throws Exception {
        Class cls = Class.forName("com.reflection.Cat");
        Object o = cls.newInstance();
        Method hi = cls.getMethod("hi");
        long start = System.currentTimeMillis();
        for (int i = 0; i < 90000000; i++) {
            hi.invoke(o);
        }
        long end = System.currentTimeMillis();
        System.out.println("m2() 耗时：" + (end - start));

    }

}

m1方法耗时总是少m2方法，说明反射影响了执行的速度。

2.4 反射调用优化

关闭访问检查：

Method和Field、Constructor对象都有setAccessible()方法；
setAccessible作用是启动和禁用访问安全检查的开关；
参数值为true表示反射的对象在使用时取消访问检查，提高反射的效率。参数值为false则表示反射的对象执行访问检查；

3. Class类

基本介绍：

Class也是类，因此也继承Object类；
Class类对象不是new出来的，而是系统创建的；
对于某个类的Class类对象，在内存中只有一份，因为类只加载一次；
每个类的实例都会记得自己是由哪个Class实例所生成；
通过Class可以完整地得到一个类的完整结构，通过一系列API；
Class对象是存放在堆的；
类的字节码二进制数据，是放在方法区的，有的地方称为类的元数据（包括方法代码，变量名，方法名，访问权限等等）；

3.1 Class类的常用方法

方法名	功能说明
static Class forName(String name)	返回指定类名name的Class对象
Object newlnstance()	调用缺省构造函数，返回该Class对象的一个实例
getName()	返回此Class对象所表示的实体(类、接口、数组类、基本类型等)名称
Class [] getInterfaces()	获取当前Class对象的接口
ClassLoader getClassLoader()	返回该类的类加载器
Class getSuperclass()	返回表示此Class所表示的实体的超类的Class
Constructor[] getConstructors()	返回一个包含某些Constructor对象的数组
Field[] getDeclaredFields()	返回Field对象的一个数组
Method getMethod(String name,Class … paramTypes)	返回一个Method对象，此对象的形参类型为paramType

应用实例：

import com.reflection.Car;
import java.lang.reflect.Field;

/**
 * 演示Class类的常用方法
 */

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

        String classAllPath = "com.reflection.Car";

        // 获取到Car 类对应的Class对象
        // <?>表示不确定的Java类型
        Class<?> cls = Class.forName(classAllPath);
        System.out.println(cls);    // 显示Class对象，是哪个类的Class对象
        System.out.println(cls.getClass());     // 运行类型
        // 得到包名
        System.out.println(cls.getPackage().getName());
        // 得到全类名
        System.out.println(cls.getName());
        // 通过cls创建对象实例
        Car car = (Car) cls.newInstance();
        System.out.println(car);
        // 通过反射获取属性（字段）
        Field brand = cls.getField("brand");
        System.out.println(brand.get(car));
        // 通过反射给属性（字段）赋值
        brand.set(car, "奔驰");
        System.out.println(brand.get(car));
        // 获取全部的属性（字段）
        Field[] fields = cls.getFields();
        for (Field f : fields) {
            System.out.println(f.getName());    // 名称
        }

    }
}

运行结果：

3.2 获取Class类对象

前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException，实例： Class cls1 =Class.forName( “java.lang.Cat” )；
**应用场景：**多用于配置文件，读取类全路径，加载类。
前提：若已知具体的类，通过类的class获取，该方式最为安全可靠，程序性能最高，实例：Class cls2 = Cat.class；
**应用场景：**多用于参数传递，比如通过反射得到对应构造器对象。
前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象，实例：Class clazz =对象.getClass()；
**应用场景：**通过创建好的对象，获取Class对象。
其他方式
ClassLoader cl =对象.getClass().getClassLoader()；
Class clazz4 = cl.loadClass( “类的全类名”)；
基本数据(int, char,boolean,float,double,byte,long,short) 按如下方式得到Class类对象
Class cls = 基本数据类型.class
基本数据类型对应的包装类，可以通过.TYPE得到Class类对象
Class cls = 包装类.TYPE

import com.reflection.Car;

public class GetClass_ {
    public static void main(String[] args) throws ClassNotFoundException {

        // 1. Class.forName
        String classAllPath = "com.reflection.Car";   // 通过配置文件获取
        Class<?> cls1 = Class.forName(classAllPath);
        System.out.println(cls1);

        // 2. 类名.class  应用：参数传递
        Class<Car> cls2 = Car.class;
        System.out.println(cls2);

        // 3. 对象.getClass()
        Car car = new Car();
        Class cls3 = car.getClass();
        System.out.println(cls3);

        // 4. 类的加载器
        // (1) 得到类加载器 car
        ClassLoader classLoader = car.getClass().getClassLoader();
        // (2) 通过加载器得到Class对象
        Class<?> cls4 = classLoader.loadClass(classAllPath);
        System.out.println(cls4);

        // 5. 基本数据类型，按以下方法
        Class<Integer> integerClass = int.class;
        Class<Character> characterClass = char.class;
        Class<Boolean> booleanClass = boolean.class;
        System.out.println(integerClass);   // int

        // 6. 包装类
        Class<Integer> type1 = Integer.TYPE;
        Class<Character> type2 = Character.TYPE;
        System.out.println(type1);  // int  与上面的integerClass是同一个（hashcode相同）

    }
}

3.3 哪些类型有Class对象

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

4. 类加载

基本说明：
反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载。
1. 静态加载：编译时加载相关的类，如果没有则报错，依赖性太强。
2. 动态加载：运行时加载需要的类，如果运行时不用该类，即使不存在该类，也不报错，降低了依赖性。
类加载时机
1. 当创建对象时(new) // 静态加载
2. 当子类被加载时，父类也加载 // 静态加载
3. 调用类中的静态成员时 // 静态加载
4. 通过反射 // 动态加载

4.1 类加载过程图

4.2 类加载各阶段完成任务

加载阶段：

JVM在该阶段的主要目的是将字节码从不同的数据源（可能是class文件、也可能是jar包，甚至网络）转化为二进制字节流加载到内存中，并生成一个代表该类的java.lang.Class对象。
连接阶段——验证：
1. 目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
2. 包括：文件格式验证（是否以魔数oxcafebabe开头）、元数据验证、字节码验证和符号引用验证。
3. 可以考虑使用-Xverify:none参数来关闭大部分的类验证措施，缩短虚拟机类加载的时间。
连接阶段——准备：
JVM会在该阶段对静态变量，分配内存并默认初始化（对应数据类型的默认初始值，如0、0L、 null、 false等）。这些变量所使用的内存都将在方法区中进行分配。
连接阶段——解析：
虚拟机将常量池内的符号引用替换为直接引用的过程。
Initialization（初始化）：
1. 到初始化阶段，才真正开始执行类中定义的Java程序代码，此阶段是执行< clinit > ()方法的过程。
2. < clinit > ()方法是由编译器按语句在源文件中出现的顺序，依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并。
3. 虚拟机会保证一个类的< clinit > ()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的< clinit >() 方法，其他线程都需要阻塞等待，直到活动线程执行< clinit > ()方法完毕。

5. 反射获取类的结构信息

5.1 第一组

java.lang.Class类

方法	说明
getName	获取全类名
getSimpleName	获取简单类名
getFields	获取所有public修饰的属性，包含本类以及父类的
getDeclaredFields	获取本类中所有属性
getMethods	获取所有public修饰的方法，包含本类以及父类的
getDeclaredMethods	获取本类中所有方法
getConstructors	获取所有public修饰的构造器，本类的
getDeclaredConstructors	获取本类中所有构造器
getPackage	以Package形式返回包信息
getSuperClass	以Class形式返回父类信息
getInterfaces	以Class[]形式返回接口信息
getAnnotations	以Annotation[]形式返回注解信息

import org.junit.jupiter.api.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * 演示如何通过反射获取类的结构信息
 */

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

    }

    @Test
    public void api_01() throws ClassNotFoundException {
        // 得到Class对象
        Class<?> personCls = Class.forName("com.reflection.Person");

        // getName  获取全类名
        System.out.println(personCls.getName());
        // getSimpleName    获取简单类名
        System.out.println(personCls.getSimpleName());
        // getFields    获取所有public修饰的属性，包含本类以及父类的
        Field[] fields = personCls.getFields();
        for (Field f : fields) {
            System.out.println("本类以及父类的属性= " + f.getName());
        }
        // getDeclaredFields    获取本类中所有属性
        Field[] declaredFields = personCls.getDeclaredFields();
        for (Field d : declaredFields) {
            System.out.println("本类所有属性= " + d.getName());
        }
        // getMethods   获取本类所有public修饰的方法
        Method[] methods = personCls.getMethods();
        for (Method m : methods) {
            System.out.println("本类以及父类的方法= " + m.getName());
        }
        // getDeclaredMethods   获取本类中所有方法
        Method[] declaredMethods = personCls.getDeclaredMethods();
        for (Method de : declaredMethods) {
            System.out.println("本类中所有方法= " + de.getName());
        }
        // getConstructors  获取所有public修饰的构造器，包含本类以及父类的
        Constructor<?>[] constructors = personCls.getConstructors();
        for (Constructor<?> c : constructors) {
            System.out.println("本类以及父类的构造器= " + c.getName());
        }
        // getDeclaredConstructors  获取本类中所有构造器
        Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
        for (Constructor<?> dec : declaredConstructors) {
            System.out.println("本类中所有构造器= " + dec.getName());
        }
        // getPackage   以Package形式返回包信息
        System.out.println(personCls.getPackage());
        // getSuperClass    以Class形式返回父类信息
        Class<?> superclass = personCls.getSuperclass();
        System.out.println("父类的class对象= " + superclass);
        // getInterfaces    以Class[]形式返回接口信息
        Class<?>[] interfaces = personCls.getInterfaces();
        for (Class<?> i : interfaces) {
            System.out.println("接口信息= " + i);
        }
        // getAnnotations   以Annotation[]形式返回注解信息
        Annotation[] annotations = personCls.getAnnotations();
        for (Annotation a : annotations) {
            System.out.println("注解信息= " + a);
        }

    }
}

class A {
    public String hobby;
    public void hi() {}
    public A() {}
}

interface IA {}
interface IB {}

@Deprecated
class Person extends A implements IA, IB {
    // 属性
    public String name;
    protected int age;
    String job;
    private double sal;

    // 构造器
    public Person() {}
    public Person(String name) {}
    private Person(String name, int age) {}

    // 方法
    public void m1() {}
    protected void m2() {}
    void m3() {}
    private void m4() {}
    
}

5.2 第二组

java.lang.reflect.Field类

方法	说明
getModifiers	以int形式返回修饰符[ 说明：默认修饰符是0，public是1，private是2，protected是4，static是8，final是16 ]
getType	以Class形式返回类型
getName	返回属性名

@Test
public void api_02() throws ClassNotFoundException {
    // 得到Class对象
    Class<?> personCls = Class.forName("com.reflection.Person");
    // getDeclaredFields    获取本类中所有属性
    Field[] declaredFields = personCls.getDeclaredFields();
    for (Field d : declaredFields) {
        System.out.println("本类所有属性= " + d.getName() + " 该属性的修饰符值= " + d.getModifiers() + " 该属性的类型= " + d.getType());
    }
}

运行结果：

5.3 第三组

java.lang.reflect.Method类

方法	说明
getModifiers	以in形式返回修饰符[ 说明：默认修饰符是0，public是1，private是2，protected是4，static是8，final是16 ]
getReturnType	以Class形式获取返回类型
getName	返回方法名
getParameterTypes	以Class[]返回参数类型数组

@Test
public void api_03() throws ClassNotFoundException {
    // 得到Class对象
    Class<?> personCls = Class.forName("com.reflection.Person");
    // getDeclaredMethods   获取本类中所有方法
    Method[] declaredMethods = personCls.getDeclaredMethods();
    for (Method de : declaredMethods) {
        System.out.println("本类中所有方法= " + de.getName() + " 该方法的修饰符值= " + de.getModifiers() + " 该方法返回类型= " + de.getReturnType());
        Class<?>[] parameterTypes = de.getParameterTypes();
        for (Class<?> p : parameterTypes) {
            System.out.println("该方法形参类型= " + p);
        }
    }
}

运行结果：

5.4 第四组

java.lang.reflect.Construct类

方法	说明
getModifiers	以int形式返回修饰符
getName	返回构造器名（全类名）
getParameterTypes	以Class[] 返回参数类型数组

6. 反射爆破

6.1 通过反射创建对象

方式一：调用类中的public修饰的无参构造器。
方式二：调用类中的指定构造器
Class类相关方法：

newInstance：调用类中的无参构造器，获取对应类的对象
getConstructor(Cas…clazz)：根据参数列表，获取对应的构造器对象
getDecalaredConstrucor(Cas…clazz)：根据参数列表，获取对应的构造器对象
Constructor类相关方法：
setAccessible：暴破
newlnstance(Object…obj)：调用构造器

应用案例：

import java.lang.reflect.Constructor;

public class ReflectCreateInstance {
    public static void main(String[] args) throws Exception {
        Class<?> userClass = Class.forName("com.reflection.User");
        // 通过public的无参构造器创建实例
        Object o = userClass.newInstance();
        System.out.println(o);      // User [name=cat,age=3]

        // 通过public的有参构造器创建实例
        Constructor<?> constructor = userClass.getConstructor(String.class);
        Object user1 = constructor.newInstance("小明");
        System.out.println("user1= " + user1);      // user1= User [name=小明,age=3]

        // 通过非public的有参构造器创建实例
        Constructor<?> constructor1 = userClass.getDeclaredConstructor(String.class, int.class);
        constructor1.setAccessible(true);   // 爆破[暴力破解]， 使用反射可以访问private构造器
        Object user2 = constructor1.newInstance("张三丰", 100);
        System.out.println("user2= " + user2);      // user2= User [name=张三丰,age=100]

    }
}

class User {
    private String name = "cat";
    private int age = 3;

    public User() {     // 无参
    }

    public User(String name) {  // public 有参
        this.name = name;
    }

    private User(String name, int age) {    // private 有参
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User [name=" + name + ",age=" + age + "]";
    }
}

6.2 通过反射访问类中属性

根据属性名获取Field对象：
Field f = clazz对象.getDeclaredField(属性名)；
暴破：
f.setAccessible(true)； // f是Field
访问：
f.set(o,值)； syso(f.get(o))； // o表示对象
**注意：**如果是静态属性，则set和get中的参数o，可以写成null。

应用案例：

import java.lang.reflect.Field;

public class ReflectAccessProperty {
    public static void main(String[] args) throws Exception {
        Class<?> stuClass = Class.forName("com.reflection.Student");
        // 创建对象
        Object o = stuClass.newInstance();
        System.out.println(o.getClass());   // class com.reflection.Student
        // 使用反射得到 age
        Field age = stuClass.getField("age");
        age.set(o, 88);  // 通过反射操作属性
        System.out.println(o);  // Student [age= 88,name= null]
        System.out.println(age.get(o));     // 88
        // 使用反射操作 name
        Field name = stuClass.getDeclaredField("name");
        // 对name爆破，可以操作private属性
        name.setAccessible(true);
        name.set(null, "小明");
        System.out.println(o);  // Student [age= 88,name= 小明]
        System.out.println(name.get(null));     // 小明
    }
}

class Student {
    public int age;
    private static String name;

    public Student() {
    }

    @Override
    public String toString() {
        return "Student [age= " + age + ",name= " + name + "]";
    }
}

6.3 通过反射访问类中方法

根据方法名和参数列表获取Method方法对象：Method m = clazz.getDeclaredMethod(方法名，XX.class)；
获取对象：Object o = clazz.newInstance()；
暴破：m.setAccessible(true)；
访问：Object returnValue = m.invoke(o,实参列表)；
**注意：**如果是静态方法，则invoke的参数o，可以写成null！

应用案例：

import java.lang.reflect.Method;

public class ReflectAccessMethod {
    public static void main(String[] args) throws Exception {
        Class<?> bossCls = Class.forName("com.reflection.Boss");
        Object o = bossCls.newInstance();
//        Method hi = bossCls.getMethod("hi",String.class);
        Method hi1 = bossCls.getDeclaredMethod("hi", String.class);
        hi1.invoke(o, "world");

        // 调用private static 方法
        Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);
        say.setAccessible(true);    // 需要 爆破
        System.out.println(say.invoke(o, 100, "张三", '男'));

    }
}

class Boss {
    public int age;
    private static String name;

    public Boss() {
    }

    private static String say(int n, String s, char c) {    // 静态方法
        return n + " " + s + " " + c;
    }

    public void hi(String s) {   // 普通public方法
        System.out.println("hi " + s);
    }
}

7. 练习

练习1：通过反射修改私有成员变量

定义PrivateTest类，有私有name属性，并且属性值为hellokitty；
提供getName的公有方法；
创建PrivateTest的类，利用Class类得到私有的name属性，修改私有的name属性值，并调用getName()的方法打印name属性值；

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Homework01 {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException {
        // 得到Class对象
        Class<privateTest> privateTestClass = privateTest.class;
        // 创建对象实例
        privateTest privateTest = privateTestClass.newInstance();
        // 得到name属性对象
        Field name = privateTestClass.getDeclaredField("name");
        // 爆破name
        name.setAccessible(true);
        name.set(privateTest, "cat");
        // 得到getName方法对象
        Method getName = privateTestClass.getMethod("getName");
        //
        Object invoke = getName.invoke(privateTest);
        System.out.println("name属性值：" + invoke);

    }
}

class privateTest {
    private String name = "hellokitty";

    public String getName() {
        return name;
    }
}

练习2：利用反射和File完成以下功能

利用Class类的forName方法得到File类的class对象；
在控制台打印File类的所有构造器；
通过newlnstance的方法创建File对象，并创建E: \mynew.txt文件；

import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

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

        Class<?> fileClass = Class.forName("java.io.File");
        Constructor<?>[] declaredConstructors = fileClass.getDeclaredConstructors();
        // 遍历输出
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println("File构造器 = " + declaredConstructor);
        }

        // 指定得到构造器
        Constructor<?> declaredConstructor = fileClass.getDeclaredConstructor(String.class);
        String filePath = "e:\\mynew.txt";
        Object file = declaredConstructor.newInstance(filePath);

        // 得到createNewFile 方法对象
        Method createNewFile = fileClass.getMethod("createNewFile");
        createNewFile.invoke(file);

    }
}