classfullpath=com.jwt.Cat method=hi这样的需求在学习框架时很多,即在通过外部文件配置,在不修改源码的情况下,来控制程序。
Cat cat = new Cat(); cat.hi();通过传统方法,确实可以调用 hi() 方法,但是这和我们的需求不一样,这里我们是要根据配置文件 re.properties 指定信息来完成。可以使用 Properties 来读取配置文件。
Properties properties = new Properties(); properties.load(new FileInputStream("src//re.properties")); String classfullpath = properties.getProperty("classfullpath");//"com.jwt.Cat" String methodName = properties.getProperty("method");//"hi" System.out.println("classfullpath=" + classfullpath); System.out.println("method=" + methodName);然后需要创建对象,怎么创建对象呢?直接new classfullpath,这样不就好了嘛?嗯,想法不错,下回不要想了。现在的 classfullpath 可是字符串类型,怎么能去new呢。所以现有技术是做不到这个事情的。那么这里就要引入我们要将的重点——反射机制。
public class ReflectionQuestion { public static void main(String[] args) throws Exception { //1. 使用Properties 类, 可以读取配置文件 Properties properties = new Properties(); properties.load(new FileInputStream("src//re.properties")); String classfullpath = properties.getProperty("classfullpath");//"com.jwt.Cat" String methodName = properties.getProperty("method");//"hi" System.out.println("classfullpath=" + classfullpath); System.out.println("method=" + methodName); // 堆代码 duidaima.com //2. 使用反射机制解决 //(1) 加载类, 返回Class类型的对象cls Class cls = Class.forName(classfullpath); System.out.println("cls = " + cls); //(2) 通过cls得到你加载的类com.jwt.Cat的对象实例 Object o = cls.newInstance(); System.out.println("o 的运行类型=" + o.getClass()); //运行类型 //(3) 通过cls得到你加载的类com.jwt.Cat的methodName "hi" 的方法对象 Method method = cls.getMethod(methodName); //(4) 通过method 调用方法: 即通过方法对象来实现调用方法 method.invoke(o); //传统方法对象.方法() , 反射机制:方法.invoke(对象) } }反射机制还有一个优点,那就是可以通过外部文件配置,在不修改源码的情况下,来控制程序。比如这里,我在Cat 类下面再写一个方法,cry()方法,如果我们使用传统方法,要调用这个方法,是不是就要修改代码了,比如cat.cry();通过反射,只需在配置文件 re.properties 中,将 method=hi 改为 method=cry 就可以了。
反射机制允许程序在执行时借助于 Reflection API 取得任何类的内部信息(比如成员变量,构造器,成员方法等等),并能操作对象的属性及方法。在运行状态中,对象可以通过反射获取他的类,类可以通过反射拿到所有⽅法(包括私有),拿到的⽅法可以调⽤,总之通过“反射”,我们可以将Java这种静态语⾔附加上动态特性。
加载完类之后,在堆中就产生了一个 Class 类型的对象(一个类只有一个Class对象) ,这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个 Class 对象就像一面镜子,透过这个镜子看到类的结构,所以,形象的称之为反射。
5.生成动态代理
package com.jwt.reflection; 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 { //1. 使用Properties 类, 可以读写配置文件 Properties properties = new Properties(); properties.load(new FileInputStream("src//re.properties")); String classfullpath = properties.get("classfullpath").toString(); String methodName = properties.get("method").toString(); //2. 使用反射机制解决 //(1) 加载类, 返回Class 类型的对象cls Class cls = Class.forName(classfullpath); //(2) 通过cls 得到你加载的类com.hspedu.Cat 的对象实例 Object o = cls.newInstance(); System.out.println("o 的运行类型=" + o.getClass()); //运行类型 //java.lang.reflect.Method:代表类的方法,Method 对象表示某个类的方法 Method method = cls.getMethod(methodName); //通过method 调用方法: 即通过方法对象来实现调用方法 method.invoke(o); // 堆代码 duidaima.com //java.lang.reflect.Field: 代表类的成员变量, Field 对象表示某个类的成员变量 //getField 不能得到私有的属性 Field nameField = cls.getField("name"); System.out.println(nameField.get(o)); // 传统写法对象.成员变量, 反射: 成员变量对象.get(对象) //java.lang.reflect.Constructor: 代表类的构造方法, Constructor 对象表示构造器 Constructor constructor = cls.getConstructor(); //()中可以指定构造器参数类型, 返回无参构造器 System.out.println(constructor);//Cat() Constructor constructor2 = cls.getConstructor(String.class); //这里传入的String.class 就是String 类的Class 对象 System.out.println(constructor2);//Cat(String name) } }
缺点:使用反射基本是解释执行,对执行速度有影响.
package com.jwt.reflection; import com.jwt.Cat; import java.lang.reflect.Method; public class Reflection02 { public static void main(String[] args) throws Exception { m1();//传统 m2();//反射 m3();//反射优化 } //传统方法来调用hi public static void m1() { Cat cat = new Cat(); long start = System.currentTimeMillis(); for (int i = 0; i < 900000000; i++) { cat.hi(); } long end = System.currentTimeMillis(); System.out.println("m1() 耗时=" + (end - start)+"ms"); } //反射机制调用方法hi public static void m2() throws Exception { Class cls = Class.forName("com.jwt.Cat"); Object o = cls.newInstance(); Method hi = cls.getMethod("hi"); long start = System.currentTimeMillis(); for (int i = 0; i < 900000000; i++) { hi.invoke(o);//反射调用方法 } long end = System.currentTimeMillis(); System.out.println("m2() 耗时=" + (end - start)+"ms"); } //反射调用优化+ 关闭访问检查 public static void m3() throws Exception { Class cls = Class.forName("com.jwt.Cat"); Object o = cls.newInstance(); Method hi = cls.getMethod("hi"); hi.setAccessible(true);//在反射调用方法时,取消访问检查 long start = System.currentTimeMillis(); for (int i = 0; i < 900000000; i++) { hi.invoke(o);//反射调用方法 } long end = System.currentTimeMillis(); System.out.println("m3() 耗时=" + (end - start)+"ms"); } } /** m1() 耗时=2ms m2() 耗时=934ms m3() 耗时=769ms **/Class 类
6.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 |
package com.jwt.reflection; import java.lang.reflect.Field; public class Class02 { public static void main(String[] args) throws Exception { String classAllPath = "com.jwt.reflection.Car"; // 堆代码 duidaima.com //1 . 获取到Car 类对应的Class 对象 Class<?> cls = Class.forName(classAllPath);//<?> 表示不确定的Java 类型 //2. 输出cls System.out.println(cls); //显示cls 对象, 是哪个类的Class 对象 System.out.println(cls.getClass());//输出cls 运行类型java.lang.Class //3. 得到包名 System.out.println(cls.getPackage().getName());//包名 //4. 得到全类名 System.out.println(cls.getName()); //5. 通过cls 创建对象实例 Car car = (Car) cls.newInstance(); System.out.println(car);//car.toString() //6. 通过反射获取属性brand Field brand = cls.getField("brand"); System.out.println(brand.get(car));//宝马 //7. 通过反射给属性赋值 brand.set(car, "奔驰"); System.out.println(brand.get(car));//奔驰 //8. 得到所有的属性(字段) System.out.println("=======所有的字段属性===="); Field[] fields = cls.getFields(); for (Field f : fields) { System.out.println(f.getName());//名称 } } } class Car { public String brand = "宝马"; public int price = 500000; public String color = "白色"; @Override public String toString() { return "Car{" + "brand='" + brand + '\'' + ", price=" + price + ", color='" + color + '\'' + '}'; } } /** class com.jwt.reflection.Car class java.lang.Class com.jwt.reflection com.jwt.reflection.Car Car{brand='宝马', price=500000, color='白色'} 宝马 奔驰 =======所有的字段属性==== brand price color **/
ClassLoader classLoader = 对象.getClass().getClassLoader(); Class cls4 = classLoader.loadClass(“类的全类名”);5、基本数据(int,char,boolean,float,double,byte,long,short)按如下方式得到Class类对象
Class cls5 = 基本数据类型.class6、基本数据类型对应的包装类,可以通过 .TYPE 得到 Class 类对象
Class cls6 = 包装类.TYPE package com.jwt.reflection; public class GetClass_ { public static void main(String[] args) throws ClassNotFoundException { //1. Class.forName String classAllPath = "com.jwt.reflection.Car"; //通过读取配置文件获取 Class<?> cls1 = Class.forName(classAllPath); System.out.println(cls1); //2. 类名.class , 应用场景: 用于参数传递 Class cls2 = Car.class; System.out.println(cls2); //3. 对象.getClass(), 应用场景,有对象实例 Car car = new Car(); Class cls3 = car.getClass(); System.out.println(cls3); //4. 通过类加载器【4 种】来获取到类的Class 对象 //(1)先得到类加载器car ClassLoader classLoader = car.getClass().getClassLoader(); //(2)通过类加载器得到Class 对象 Class cls4 = classLoader.loadClass(classAllPath); System.out.println(cls4); //5. 基本数据(int, char,boolean,float,double,byte,long,short) 按如下方式得到Class 类对象 Class<Integer> cls5 = int.class; System.out.println(cls5);//int //6. 基本数据类型对应的包装类,可以通过.TYPE 得到Class 类对象 Class<Integer> cls6 = Integer.TYPE; System.out.println(cls6); } } /** class com.jwt.reflection.Car class com.jwt.reflection.Car class com.jwt.reflection.Car class com.jwt.reflection.Car int int **/
package com.jwt.reflection; import java.io.Serializable; public class AllTypeClass { public static void main(String[] args) { Class<String> aClass1 = String.class;//外部类 Class<Serializable> aClass2 = Serializable.class;//接口 Class<Integer[]> aClass3 = Integer[].class;//数组 Class<Integer[][]> aClass4 = Integer[][].class;//二维数组 Class<Deprecated> aClass5 = Deprecated.class;//注解 Class<Thread.State> aClass6 = Thread.State.class;//枚举 Class<Long> aClass7 = long.class;//基本数据类型 Class<Void> aClass8 = void.class;//void数据类型 Class<Class> aClass9 = Class.class;//Class类 System.out.println(aClass1); System.out.println(aClass2); System.out.println(aClass3); System.out.println(aClass4); System.out.println(aClass5); System.out.println(aClass6); System.out.println(aClass7); System.out.println(aClass8); System.out.println(aClass9); } }
Dog dog = new Dog();动态加载:运行时加载需要的类,编译不报错,降低了依赖性
Class cls = Class.forName("Person"); Object o = cls.newInstance(); Method method = cls.getMethod("hi"); method.invoke(o);类加载时机
4.通过反射 //动态加载
class A { //分析类加载的链接阶段-准备属性是如何处理 //1. n1 是实例属性, 不是静态变量,因此在准备阶段,是不会分配内存 //2. n2 是静态变量,分配内存n2 默认初始化0 ,而不是20 //3. n3 是static final 是常量, 他和静态变量不一样, 因为一旦赋值就不变n3 = 30 public int n1 = 10; public static int n2 = 20; public static final int n3 = 30; }
虚拟机会保证一个类的 () 方法在多线程环境中被正确的加锁、同步,如果多个线程同时去初始化一个类,那么只会有一个线程去执行这个类的 () 方法,其他线程都需要阻塞等待,直到活动线程执行 () 方法完毕。
@Test public void api_01() throws ClassNotFoundException, NoSuchMethodException { //得到Class 对象 Class<?> personCls = Class.forName("com.jwt.reflection.Person"); //getName:获取全类名 System.out.println(personCls.getName());//com.hspedu.reflection.Person //getSimpleName:获取简单类名 System.out.println(personCls.getSimpleName());//Person //getFields:获取所有public 修饰的属性,包含本类以及父类的 Field[] fields = personCls.getFields(); for (Field field : fields) {//增强for System.out.println("本类以及父类的属性=" + field.getName()); } System.out.println("=========================="); //getDeclaredFields:获取本类中所有属性 Field[] declaredFields = personCls.getDeclaredFields(); for (Field declaredField : declaredFields) { System.out.println("本类中所有属性=" + declaredField.getName()); } System.out.println("=========================="); //getMethods:获取所有public 修饰的方法,包含本类以及父类的 Method[] methods = personCls.getMethods(); for (Method method : methods) { System.out.println("本类以及父类的方法=" + method.getName()); } System.out.println("=========================="); //getDeclaredMethods:获取本类中所有方法 Method[] declaredMethods = personCls.getDeclaredMethods(); for (Method declaredMethod : declaredMethods) { System.out.println("本类中所有方法=" + declaredMethod.getName()); } System.out.println("=========================="); //getConstructors: 获取所有public 修饰的构造器,包含本类 Constructor<?>[] constructors = personCls.getConstructors(); for (Constructor<?> constructor : constructors) { System.out.println("本类的构造器=" + constructor.getName()); } System.out.println("=========================="); //getDeclaredConstructors:获取本类中所有构造器 Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors(); for (Constructor<?> declaredConstructor : declaredConstructors) { System.out.println("本类中所有构造器=" + declaredConstructor.getName());//这里老师只是输出名 } System.out.println("=========================="); //getPackage:以Package 形式返回包信息 System.out.println(personCls.getPackage());//com.hspedu.reflection //getSuperClass:以Class 形式返回父类信息 Class<?> superclass = personCls.getSuperclass(); System.out.println("父类的class 对象=" + superclass); System.out.println("=========================="); //getInterfaces:以Class[]形式返回接口信息 Class<?>[] interfaces = personCls.getInterfaces(); for (Class<?> anInterface : interfaces) { System.out.println("接口信息=" + anInterface); } System.out.println("=========================="); //getAnnotations:以Annotation[] 形式返回注解信息 Annotation[] annotations = personCls.getAnnotations(); for (Annotation annotation : annotations) { System.out.println("注解信息=" + annotation);//注解 } } /** com.jwt.reflection.Person Person 本类以及父类的属性=name 本类以及父类的属性=hobby ========================== 本类中所有属性=name 本类中所有属性=age 本类中所有属性=job 本类中所有属性=sal ========================== 本类以及父类的方法=m1 本类以及父类的方法=hi 本类以及父类的方法=wait 本类以及父类的方法=wait 本类以及父类的方法=wait 本类以及父类的方法=equals 本类以及父类的方法=toString 本类以及父类的方法=hashCode 本类以及父类的方法=getClass 本类以及父类的方法=notify 本类以及父类的方法=notifyAll ========================== 本类中所有方法=m1 本类中所有方法=m2 本类中所有方法=m4 本类中所有方法=m3 ========================== 本类的构造器=com.jwt.reflection.Person 本类的构造器=com.jwt.reflection.Person ========================== 本类中所有构造器=com.jwt.reflection.Person 本类中所有构造器=com.jwt.reflection.Person 本类中所有构造器=com.jwt.reflection.Person ========================== package com.jwt.reflection 父类的class 对象=class com.jwt.reflection.A ========================== 接口信息=interface com.jwt.reflection.IA 接口信息=interface com.jwt.reflection.IB ========================== **/
class A { public String hobby; public void hi() {} public A() {} public A(String name) {} } interface IA { } interface IB { } @Deprecated class Person extends A implements IA, IB { //属性 public String name; protected static int age; // 4 + 8 = 12 String job; private double sal; //构造器 public Person() {} public Person(String name) {} //私有的 private Person(String name, int age) {} //方法 public void m1(String name, int age, double sal) {} protected String m2() { return null; } void m3() {} private void m4() {} }
@Test public void api_02() throws ClassNotFoundException, NoSuchMethodException { //得到Class 对象 Class<?> personCls = Class.forName("com.jwt.reflection.Person"); //java.lang.reflect.Field //规定说明: 默认修饰符是0 , public 是1 ,private 是2 ,protected 是4 , static 是8 ,final 是16 Field[] declaredFields = personCls.getDeclaredFields(); for (Field declaredField : declaredFields) { System.out.println("本类中所有属性=" + declaredField.getName() + " 该属性的修饰符值=" + declaredField.getModifiers() + " 该属性的类型=" + declaredField.getType() ); } System.out.println("=========================="); //java.lang.reflect.Mehod Method[] declaredMethods = personCls.getDeclaredMethods(); for (Method declaredMethod : declaredMethods) { System.out.println("本类中所有方法=" + declaredMethod.getName() + " 该方法的访问修饰符值=" + declaredMethod.getModifiers() + " 该方法返回类型" + declaredMethod.getReturnType() ); } for (Method declaredMethod : declaredMethods) { //输出当前这个方法的形参数组情况 Class<?>[] parameterTypes = declaredMethod.getParameterTypes(); for (Class<?> parameterType : parameterTypes) { System.out.println("该方法的形参类型=" + parameterType); } } System.out.println("=========================="); //java.lang.reflect.Constructor Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors(); for (Constructor<?> declaredConstructor : declaredConstructors) { System.out.println("本类中所有构造器=" + declaredConstructor.getName());//只是输出名 } for (Constructor<?> declaredConstructor : declaredConstructors) { Class<?>[] parameterTypes = declaredConstructor.getParameterTypes(); for (Class<?> parameterType : parameterTypes) { System.out.println("该构造器的形参类型=" + parameterType); } } } /** 本类中所有属性=name 该属性的修饰符值=1 该属性的类型=class java.lang.String 本类中所有属性=age 该属性的修饰符值=12 该属性的类型=int 本类中所有属性=job 该属性的修饰符值=0 该属性的类型=class java.lang.String 本类中所有属性=sal 该属性的修饰符值=2 该属性的类型=double ========================== 本类中所有方法=m1 该方法的访问修饰符值=1 该方法返回类型void 本类中所有方法=m2 该方法的访问修饰符值=4 该方法返回类型class java.lang.String 本类中所有方法=m4 该方法的访问修饰符值=2 该方法返回类型void 本类中所有方法=m3 该方法的访问修饰符值=0 该方法返回类型void 该方法的形参类型=class java.lang.String 该方法的形参类型=int 该方法的形参类型=double ========================== 本类中所有构造器=com.jwt.reflection.Person 本类中所有构造器=com.jwt.reflection.Person 本类中所有构造器=com.jwt.reflection.Person 该构造器的形参类型=class java.lang.String 该构造器的形参类型=int 该构造器的形参类型=class java.lang.String **/
import java.lang.reflect.Constructor; public class ReflecCreateInstance { public static void main(String[] args) throws Exception { //1. 先获取到User 类的Class 对象 Class<?> userClass = Class.forName("com.jwt.reflection.User"); //2. 通过public 的无参构造器创建实例 Object user1 = userClass.newInstance(); System.out.println(user1); //3. 通过public 的有参构造器创建实例 //3.1 先得到对应构造器 Constructor<?> constructor = userClass.getConstructor(String.class); //3.2 创建实例,并传入实参 Object user2 = constructor.newInstance("小简"); System.out.println(user2); //4. 通过非public 的有参构造器创建实例 //4.1 得到private 的构造器对象 Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class, String.class); //4.2 创建实例 //暴破【暴力破解】, 使用反射可以访问private 构造器/方法/属性 constructor1.setAccessible(true); Object user3 = constructor1.newInstance(100, "张三丰"); System.out.println(user3); } } class User { private int age = 10; private String name = "小明"; public User() {//无参public } public User(String name) {//public 的有参构造器 this.name = name; } private User(int age, String name) {//private 有参构造器 this.age = age; this.name = name; } @Override public String toString() { return "User [age=" + age + ", name=" + name + "]"; } }
package com.jwt.reflection; import java.lang.reflect.Field; public class ReflecAccessProperty { public static void main(String[] args) throws Exception { //1. 得到Student 类对应的Class 对象 Class<?> stuClass = Class.forName("com.jwt.reflection.Student"); //2. 创建对象 Object o = stuClass.newInstance();//o 的运行类型就是Student System.out.println(o.getClass());//Student System.out.println(o); //3. 使用反射得到age 属性对象 Field age = stuClass.getField("age"); System.out.println(age.get(o));//返回age 属性的值 age.set(o, 88);//通过反射来操作属性 System.out.println(o); System.out.println(age.get(o)); //4. 使用反射操作name 属性 Field name = stuClass.getDeclaredField("name"); //对name 进行暴破, 可以操作private 属性 name.setAccessible(true); name.set(o, "小明"); System.out.println(name.get(o)); //获取属性值 System.out.println(o); name.set(null, "小红");//因为name 是static属性,因此o 也可以用null System.out.println(name.get(null));//获取属性值, 要求name 是static System.out.println(o); } } class Student {//类 public int age; private static String name; public Student() {//构造器 } @Override public String toString() { return "Student [age=" + age + ", name=" + name + "]"; } }
package com.jwt.reflection; import java.lang.reflect.Method; public class ReflecAccessMethod { public static void main(String[] args) throws Exception { //1. 得到Boss 类对应的Class 对象 Class<?> bossCls = Class.forName("com.jwt.reflection.Boss"); //2. 创建对象 Object o = bossCls.newInstance(); //3. 调用public 的hi 方法 //3.1 得到hi 方法对象 Method hi = bossCls.getMethod("hi", String.class);//OK //Method hi = bossCls.getDeclaredMethod("hi", String.class);//OK //3.2 调用 hi.invoke(o, "小明"); //4. 调用private static 方法 //4.1 得到say 方法对象 Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class); //4.2 因为say 方法是private, 所以需要暴破,原理和前面讲的构造器和属性一样 say.setAccessible(true); System.out.println(say.invoke(o, 100, "张三", '男')); //4.3 因为say 方法是static 的,还可以这样调用,可以传入null System.out.println(say.invoke(null, 200, "李四", '女')); //5. 在反射中,如果方法有返回值,统一返回Object , 但是他运行类型和方法定义的返回类型一致 Object reVal = say.invoke(null, 300, "王五", '男'); System.out.println("reVal 的运行类型=" + reVal.getClass());//String //在演示一个返回的案例 Method m1 = bossCls.getDeclaredMethod("m1"); Object reVal2 = m1.invoke(o); System.out.println("reVal2 的运行类型=" + reVal2.getClass());//Monster } } class Monster {} class Boss {//类 public int age; private static String name; public Boss() {//构造器 } public Monster m1() { return new Monster(); } 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); } }
package com.jwt.reflection; 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 ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException { Class<?> aClass = Class.forName("com.jwt.reflection.PrivateTest"); Object o = aClass.newInstance(); Field name = aClass.getDeclaredField("name"); name.setAccessible(true); name.set(o,"小明"); Method getName = aClass.getMethod("getName"); Object returnValue = getName.invoke(o); System.out.println("returnValue = " + returnValue); } } class PrivateTest{ private String name = "hellokitty"; public String getName() { return name; } }
File file = new File(“路径”); file.createNewFile(); package com.jwt.reflection; 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 Exception, { //得到 File 类的 class 对象 Class<?> aClass = Class.forName("java.io.File"); //打印 File 类的所有构造器 Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors(); for (Constructor<?> i:declaredConstructors){ System.out.println("File构造器 = " + i); } //指定构造器创建File对象 Constructor<?> dc = aClass.getDeclaredConstructor(String.class); Object fileObj = dc.newInstance("/Users/jianjian/Downloads/mynew.txt"); //得到createNewFile的方法对象 Method createNewFile = aClass.getMethod("createNewFile"); createNewFile.invoke(fileObj); System.out.println("创建成功"); } }