0基础学java-day23(反射)-编程知识

一、反射机制

1、一个需求引出反射

package com.hspedu.reflection.question;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;/*** @author 林然* @version 1.0* 反射问题的引入*/
@SuppressWarnings("all")
public class ReflectionQuestion {public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {//根据配置文件 re.properties 指定信息, 创建 Cat 对象并调用方法 hi//传统的方式 new 对象 -》 调用方法// Cat cat = new Cat();// cat.hi(); ===> cat.cry() 修改源码.//我们尝试做一做 -> 明白反射//1 使用 Properties 类, 可以读写配置文件Properties properties =new Properties();properties.load(new FileInputStream("src\\re.properties"));String classfullpath =properties.get("classfullpath").toString();String method = properties.get("method").toString();System.out.println("classfullpath"+classfullpath);System.out.println("method"+method);//创建对象, 传统的方法，行不通 =》 反射机制//new classfullpath();//3. 使用反射机制解决//(1) 加载类, 返回 Class 类型的对象 clsClass cls = Class.forName(classfullpath);//通过cls得到加载的类 com.hspedu.Cat的对象实例Object o =cls.newInstance();System.out.println("o 的运行类型=" + o.getClass()); //运行类型//(3) 通过 cls 得到你加载的类 com.hspedu.Cat 的 methodName"hi" 的方法对象// 即：在反射中，可以把方法视为对象（万物皆对象）Method method1 = cls.getMethod(method);//(4) 通过 method1 调用方法: 即通过方法对象来实现调用方法System.out.println("=============================");method1.invoke(o);}
}

2 反射机制

2.1 Java Reflection

2.2 Java 反射机制原理示意图!!!

2.3 Java 反射机制可以完成

2.4 反射相关的主要类

package com.hspedu.reflection.question;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;/*** @author 林然* @version 1.0*/
public class Reflection01 {public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {//根据配置文件 re.properties 指定信息, 创建 Cat 对象并调用方法 hi//传统的方式 new 对象 -》 调用方法// Cat cat = new Cat();// cat.hi(); ===> cat.cry() 修改源码.//我们尝试做一做 -> 明白反射//1 使用 Properties 类, 可以读写配置文件Properties properties =new Properties();properties.load(new FileInputStream("src\\re.properties"));String classfullpath =properties.get("classfullpath").toString();String method = properties.get("method").toString();System.out.println("classfullpath"+classfullpath);System.out.println("method"+method);//创建对象, 传统的方法，行不通 =》 反射机制//new classfullpath();//3. 使用反射机制解决//(1) 加载类, 返回 Class 类型的对象 clsClass cls = Class.forName(classfullpath);//通过cls得到加载的类 com.hspedu.Cat的对象实例Object o =cls.newInstance();System.out.println("o 的运行类型=" + o.getClass()); //运行类型//(3) 通过 cls 得到你加载的类 com.hspedu.Cat 的 methodName"hi" 的方法对象// 即：在反射中，可以把方法视为对象（万物皆对象）Method method1 = cls.getMethod(method);//(4) 通过 method1 调用方法: 即通过方法对象来实现调用方法System.out.println("=============================");method1.invoke(o);//java.lang.reflect.Field: 代表类的成员变量, Field 对象表示某个类的成员变量//得到 name 字段//getField 不能得到私有的属性Field nameField = cls.getField("age");// 传统写法 对象.成员变量 , 反射 : 成员变量对象.get(对象)System.out.println(nameField.get(o));//java.lang.reflect.Constructor: 代表类的构造方法, Constructor 对象表示构造器Constructor constructor = cls.getConstructor();//()中可以指定构造器参数类型, 返回无参构造器System.out.println(constructor);Constructor constructor1 = cls.getConstructor(String.class);//这里老师传入的 String.class 就是 String 类的Class 对象System.out.println(constructor1);}
}

2.5 反射优点和缺点

package com.hspedu.reflection.question;import com.hspedu.Cat;import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;/*** @author 林然* @version 1.0* 测试反射调用的性能，和优化方案*/
public class Reflection02 {public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {m1();m2();}//传统方法来调用hipublic 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("传统方法来调用hi 耗时="+(end-start));}//反射机制来调用hipublic static void m2() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {Class cls = Class.forName("com.hspedu.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("反射机制来调用hi 耗时="+(end-start));}
}

2.6 反射调用优化-关闭访问检查

package com.hspedu.reflection.question;import com.hspedu.Cat;import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;/*** @author 林然* @version 1.0* 测试反射调用的性能，和优化方案*/
public class Reflection02 {public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {m1();m2();m3();}//传统方法来调用hipublic 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("传统方法来调用hi 耗时="+(end-start));}//反射机制来调用hipublic static void m2() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {Class cls = Class.forName("com.hspedu.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反射机制来调用hi 耗时="+(end-start));//}//反射机制来调用hipublic static void m3() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {Class cls = Class.forName("com.hspedu.Cat");Object o=cls.newInstance();Method hi = cls.getMethod("hi");//反射调用优化+关闭访问检查hi.setAccessible(true);//在反射调用方法时，取消访问检测long start =System.currentTimeMillis();for(int i=0;i<90000000;i++){hi.invoke(o);}long end =System.currentTimeMillis();System.out.println("m3反射机制来调用hi 耗时="+(end-start));//}
}

二、Class类

1 基本介绍

package com.hspedu.reflection.class_;import com.hspedu.Cat;/*** @author 林然* @version 1.0* 梳理对class类特点的梳理*/
public class Class01 {public static void main(String[] args) throws ClassNotFoundException {//看看 Class 类图//1. Class 也是类，因此也继承 Object 类//Class//2. Class 类对象不是 new 出来的，而是系统创建的//(1) 传统 new 对象/* ClassLoader 类public Class<?> loadClass(String name) throws ClassNotFoundException {return loadClass(name, false);}*/Cat cat =new Cat() ;//(2) 反射方式, 刚才老师没有 debug 到 ClassLoader 类的 loadClass, 原因是，我没有注销Cat cat = new Cat();/*ClassLoader 类, 仍然是通过 ClassLoader 类加载 Cat 类的 Class 对象public Class<?> loadClass(String name) throws ClassNotFoundException {return loadClass(name, false);}*///3. 对于某个类的 Class 类对象，在内存中只有一份，因为类只加载一次Class cls1 = Class.forName("com.hspedu.Cat");Class cls2 = Class.forName("com.hspedu.Cat");System.out.println(cls1.hashCode());//相同System.out.println(cls2.hashCode());//相同//Class cls3 = Class.forName("com.hspedu.Dog");//System.out.println(cls3.hashCode());Object cat1= null;Object cat2 = null;try {cat1 = cls1.newInstance();cat2 = cls2.newInstance();} catch (InstantiationException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();}System.out.println(cat1.hashCode());//不同System.out.println(cat2.hashCode());//不同}
}

2 Class 类的常用方法

3 应用实例：

package com.hspedu.reflection.class_;import com.hspedu.Car;import java.lang.reflect.Field;/*** @author 林然* @version 1.0* 演示Class的常用方法*/
public class Calss02 {public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {String classAllPath ="com.hspedu.Car";//1 获取到Car对应的Class对象//<?> 表示不确定的 Java 类型Class<?> cls = Class.forName(classAllPath);//2 输出clsSystem.out.println(cls);//显示 cls 对象, 是哪个类的 Class 对象 com.hspedu.CarSystem.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. 通过反射获取属性 brandField 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());//名称}}
}

4 获取 Class 类对象

package com.hspedu.reflection.class_;import com.hspedu.Car;/*** @author 林然* @version 1.0* 演示得到 Class 对象的各种方式(6)*/
public class GetClass_ {public static void main(String[] args) throws ClassNotFoundException {//1. Class.forNameString classAllPath = "com.hspedu.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)先得到类加载器 carClassLoader classLoader = car.getClass().getClassLoader();//(2)通过类加载器得到 Class 对象Class cls4 = classLoader.loadClass(classAllPath);System.out.println(cls4);//cls1 , cls2 , cls3 , cls4 其实是同一个对象System.out.println(cls1.hashCode());System.out.println(cls2.hashCode());System.out.println(cls3.hashCode());System.out.println(cls4.hashCode());//5. 基本数据(int, char,boolean,float,double,byte,long,short) 按如下方式得到 Class 类对象Class<Integer> integerClass = int.class;Class<Character> characterClass = char.class;Class<Boolean> booleanClass = boolean.class;System.out.println(integerClass);//int//6. 基本数据类型对应的包装类，可以通过 .TYPE 得到 Class 类对象Class<Integer> type1 = Integer.TYPE;Class<Character> type2 = Character.TYPE; //其它包装类 BOOLEAN, DOUBLE, LONG,BYTE 等待System.out.println(type1);System.out.println(integerClass.hashCode());//?System.out.println(type1.hashCode());//?}
}

5 哪些类型有 Class 对象

5.1 如下类型有 Class 对象

5.2 应用实例

package com.hspedu.reflection.class_;import java.io.Serializable;/*** @author 林然* @version 1.0* 演示哪些类型有 Class 对象*/
public class AllTypeClass {public static void main(String[] args) {Class<String> cls1 = String.class;//外部类Class<Serializable> cls2 = Serializable.class;//接口Class<Integer[]> cls3 = Integer[].class;//数组Class<float[][]> cls4 = float[][].class;//二维数组Class<Deprecated> cls5 = Deprecated.class;//注解Class<Thread.State> cls6 = Thread.State.class;//枚举Class<Long> cls7 = long.class;//基本数据类型Class<Void> cls8 = void.class;//void 数据类型Class<Class> cls9 = Class.class;//System.out.println(cls1);System.out.println(cls2);System.out.println(cls3);System.out.println(cls4);System.out.println(cls5);System.out.println(cls6);System.out.println(cls7);System.out.println(cls8);System.out.println(cls9);}
}

三、类加载

1 基本说明

2 类加载时机

3 类加载过程图

4 类加载各阶段完成任务

5 加载阶段

6 连接阶段-验证

7 连接阶段-准备

package com.hspedu.reflection.class_;/*** @author 林然* @version 1.0* 我们说明一个类加载的链接阶段-准备*/
public class ClassLoad02 {public static void main(String[] args) {}
}
class A{//属性-成员变量-字段//分析类加载的链接阶段-准备 属性是如何处理//1. n1 是实例属性, 不是静态变量，因此在准备阶段，是不会分配内存//2. n2 是静态变量，分配内存 n2 是默认初始化 0 ,而不是 20;在初始化阶段才会是20//3. n3 是 static final 是常量, 他和静态变量不一样, 因为一旦赋值就不变 n3 = 30public int n1 = 10;public static int n2 = 20;public static final int n3 = 30;
}

8 连接阶段-解析

9 Initialization（初始化)

package com.hspedu.reflection.class_;/*** @author 林然* @version 1.0* 演示类加载-初始化阶段*/
public class ClassLoad03 {public static void main(String[] args) {//1. 加载 B 类，并生成 B 的 class 对象//2. 链接 num = 0//3. 初始化阶段// 依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句,并合并/*clinit() {System.out.println("B 静态代码块被执行");//num = 300;num = 100;}合并: num = 100*///new B();//类加载//System.out.println(B.num);//100, 如果直接使用类的静态属性，也会导致类的加载//看看加载类的时候，是有同步机制控制/*protected Class<?> loadClass(String name, boolean resolve)throws ClassNotFoundException{//正因为有这个机制，才能保证某个类在内存中, 只有一份 Class 对象synchronized (getClassLoadingLock(name)) {//.... }}*/B b = new B();}
}
class B{static {System.out.println("B 静态代码块被执行");num = 300;}static int num = 100;public B() {//构造器System.out.println("B() 构造器被执行");}
}

四、反射获取类的结构信息

1 第一组: java.lang.Class 类

2 第二组: java.lang.reflect.Field 类

3 第三组: java.lang.reflect.Method 类

4 第四组: java.lang.reflect.Constructor 类

package com.hspedu.reflection;import org.junit.Test;import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;/*** @author 林然* @version 1.0* 演示如何通过反射获取类的结构信息*/
public class ReflectionUtils {public static void main(String[] args) {}//第一组方法 API@Testpublic void api_01() throws ClassNotFoundException {//得到Class对象Class<?> personCls = Class.forName("com.hspedu.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){System.out.println("本类以及父类的属性："+field.getName());}//getDeclaredFields:获取本类中所有属性Field[] declaredFields = personCls.getDeclaredFields();for (Field declaredField : declaredFields) {System.out.println("本类中所有属性="+declaredField.getName());}//getMethods:获取所有 public 修饰的方法，包含本类以及父类的【不局限于直接父类Method[] methods = personCls.getMethods();for (Method method : methods) {System.out.println("本类以及父类的方法="+method.getName());}//getDeclaredMethods:获取本类中所有方法Method[] declaredMethods = personCls.getDeclaredMethods();for (Method declaredMethod : declaredMethods) {System.out.println("本类中所有方法=" + declaredMethod.getName());}//getConstructors: 获取所有 public 修饰的构造器，包含本类Constructor<?>[] constructors = personCls.getConstructors();for (Constructor<?> constructor : constructors) {System.out.println("本类的构造器=" + constructor.getName());}//getDeclaredConstructors:获取本类中所有构造器Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();for (Constructor<?> declaredConstructor : declaredConstructors) {System.out.println("本类中所有构造器=" + declaredConstructor.getName());//这里老师只是输出名}//getPackage:以 Package 形式返回 包信息System.out.println(personCls.getPackage());//com.hspedu.reflection//getSuperClass:以 Class 形式返回父类信息Class<?> superclass = personCls.getSuperclass();System.out.println("父类的 class 对象=" + superclass);////getInterfaces:以 Class[]形式返回接口信息Class<?>[] interfaces = personCls.getInterfaces();for (Class<?> anInterface : interfaces) {System.out.println("接口信息=" + anInterface);}//getAnnotations:以 Annotation[] 形式返回注解信息Annotation[] annotations = personCls.getAnnotations();for (Annotation annotation : annotations) {System.out.println("注解信息=" + annotation);//注解}}@Testpublic void api_02() throws ClassNotFoundException {//得到 Class 对象Class<?> personCls = Class.forName("com.hspedu.reflection.Person");//getDeclaredFields:获取本类中所有属性//规定 说明: 默认修饰符 是 0 ， public 是 1 ，private 是 2 ，protected 是 4 , static 是 8 ，final 是 16Field[] declaredFields = personCls.getDeclaredFields();for (Field declaredField : declaredFields) {System.out.println("本类中所有属性=" + declaredField.getName()+" 该属性的修饰符值=" + declaredField.getModifiers()+ " 该属性的类型=" + declaredField.getType());}//getDeclaredMethods:获取本类中所有方法Method[] declaredMethods = personCls.getDeclaredMethods();for (Method declaredMethod : declaredMethods) {System.out.println("本类中所有方法=" + declaredMethod.getName()+ " 该方法的访问修饰符值=" + declaredMethod.getModifiers()+ " 该方法返回类型" + declaredMethod.getReturnType());//输出当前这个方法的形参数组情况Class<?>[] parameterTypes = declaredMethod.getParameterTypes();for (Class<?> parameterType : parameterTypes) {System.out.println("该方法的形参类型=" + parameterType);}}//getDeclaredConstructors:获取本类中所有构造器Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();for (Constructor<?> declaredConstructor : declaredConstructors) {System.out.println("====================");System.out.println("本类中所有构造器=" + declaredConstructor.getName());//这里老师只是输出名Class<?>[] parameterTypes = declaredConstructor.getParameterTypes();for (Class<?> parameterType : parameterTypes) {System.out.println("该构造器的形参类型=" + parameterType);}}}
}
interface IA {
}
interface IB {
}
class A{public String hobby;public void hi() {}public A() {}public A(String name) {}
}
@Deprecated
class Person extends A implements IA,IB{//属性public String name;protected static int age; // 4 + 8 = 12String 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() {}
}

五、通过反射创建对象

案例演示：

package com.hspedu.reflection;import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;/*** @author 林然* @version 1.0* 演示通过反射机制创建实例*/
public class ReflecCreateInstance {public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {//1. 先获取到 User 类的 Class 对象Class<?> userClass = Class.forName("com.hspedu.reflection.User");//2. 通过 public 的无参构造器创建实例Object o=userClass.newInstance();System.out.println(o);//3. 通过 public 的有参构造器创建实例/*constructor 对象就是public User(String name) {//public 的有参构造器this.name = name;}*///3.1 先得到对应构造器Constructor<?> constructor = userClass.getConstructor(String.class);//3.2 创建实例，并传入实参Object lin = constructor.newInstance("琳琳");System.out.println("lin=" + lin);//4. 通过非 public 的有参构造器创建实例//4.1 得到 private 的构造器对象Constructor<?> declaredConstructor = userClass.getDeclaredConstructor(int.class, String.class);//4.2 创建实例//暴破【暴力破解】 , 使用反射可以访问 private 构造器/方法/属性, 反射面前，都是纸老虎declaredConstructor.setAccessible(true);Object liming = declaredConstructor.newInstance(18, "黎明");System.out.println("liming="+liming);}
}
class User { //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;}public String toString() {return "User [age=" + age + ", name=" + name + "]";}
}

六、通过反射访问类中的成员

1 访问属性 ReflecAccessProperty.java

package com.hspedu.reflection;import java.lang.reflect.Field;/*** @author 林然* @version 1.0* 演示反射操作属性*/
public class ReflecAccessProperty {public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {//1. 得到 Student 类对应的 Class 对象Class<?> StuClass = Class.forName("com.hspedu.reflection.Student");//2. 创建对象Object o = StuClass.newInstance();//o 的运行类型就是 StudentSystem.out.println(o.getClass());//Student//3. 使用反射得到 age 属性对象Field age = StuClass.getField("age");age.set(o,88);//通过反射来操作属性System.out.println(o);//System.out.println(age.get(o));//返回 age 属性的值//4. 使用反射操作 name 属性Field name = StuClass.getDeclaredField("name");//对 name 进行暴破, 可以操作 private 属性name.setAccessible(true);name.set(0,"林然");System.out.println(o);name.set(null, "老刘~");//因为 name 是 static 属性，因此 o 也可以写出 nullSystem.out.println(o);System.out.println(name.get(o)); //获取属性值System.out.println(name.get(null));//获取属性值, 要求 name 是 static}
}
class Student{public int age;private static String name;public Student() {//构造器}public String toString() {return "Student [age=" + age + ", name=" + name + "]";}
}

2 访问方法 ReflecAccessMethod.java

package com.hspedu.reflection;import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;/*** @author 林然* @version 1.0* 演示通过反射调用方法*/
public class ReflecAccessMethod {public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {//1. 得到 Boss 类对应的 Class 对象Class<?> bossCls = Class.forName("com.hspedu.reflection.Boss");//2. 创建对象Object o = bossCls.newInstance();//3. 调用 public 的 hi 方法//Method hi = bossCls.getMethod("hi", String.class);//OK//3.1 得到 hi 方法对象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 的，还可以这样调用 ，可以传入 nullSystem.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){System.out.println("hi " + s);}
}

七、本章作业

1.作业一

package com.hspedu.homework;import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;/*** @author 林然* @version 1.0*/
public class Homework01 {public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException {Class<?> aClass = Class.forName("com.hspedu.homework.PrivateTest");Object o = aClass.newInstance();Field name = aClass.getDeclaredField("name");name.setAccessible(true);name.set(o,"linran");//System.out.println(name.get(o));Method getName = aClass.getMethod("getName");System.out.println(getName.invoke(o));}
}
class PrivateTest{private String name="hello林然";public String getName() {return name;}
}

2.作业二

package com.hspedu.homework;import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;/*** @author 林然* @version 1.0*/
public class Homework02 {public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {Class<?> fileClass = Class.forName("java.io.File");Constructor<?>[] declaredConstructors = fileClass.getDeclaredConstructors();for (Constructor<?> declaredConstructor : declaredConstructors) {System.out.println("File的构造器="+declaredConstructor.getName());}Constructor<?> declaredConstructor = fileClass.getDeclaredConstructor(String.class);String fileAllPath="e:\\mynew.txt";Object fiel = declaredConstructor.newInstance(fileAllPath);//创建了File对象Method createNewFile = fileClass.getMethod("createNewFile");createNewFile.invoke(fiel);//创建文件成功}
}