哈喽!大家好,我是小简。今天开始学习《Java-反射》,此系列是我做的一个 “Java 从 0 到 1 ” 实验,给自己一年左右时间,按照我自己总结的 Java-学习路线,从 0 开始学 Java 知识,并不定期更新所学笔记,期待一年后的蜕变吧!
根据配置文件 re.properties 指定信息,创建 Cat 对象并调用方法 hi
classfullpath=com.jwt.Cat
method=hi
这样的需求在学习框架时很多,即在通过外部文件配置,在不修改源码的情况下,来控制程序。
传统的方法是先 new 一个对象,然后再调用它的方法。
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
呢。所以现有技术是做不到这个事情的。那么这里就要引入我们要将的重点——反射机制。
package com.jwt.reflection;
import java.io.FileInputStream;
import java.lang.reflect.Method;
import java.util.Properties;
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);
//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 就可以了。
一句话总结:反射就是在运行时才知道要操作的类是什么,并且可以在运行时获取类的完整构造,并调用对应的方法。动态特性
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);
//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
**/
方法名 | 功能说明 |
---|---|
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";
//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
**/
1、Class.forName
前提:已知一个类的全名称,且该类路径下,可通过 Class 类的静态方法 forName() 获取,可能抛出ClassNotFoundException 异常
实例:Class cls1 = Class.forName(“java.lang.Cat”);
应用场景:多用于配置文件,读取类全路径,加载类
2、类名.class
前提:若已知具体的类,通过类的 class 获取,该方式最为安全可靠,程序性能最高
实例:Class cls2 = Car.class;
应用场景:多用于参数传递,比如通过反射得到对应构造器对象
3、对象.getClass()
前提:已知某个类的实例,调用该实例的 getClass() 方法获取 Class 对象
实例:Class cls3 = 对象.getClass();//运行类型
应用场景:通过创建好的对象,获取 Class 对象
4、通过类加载器
ClassLoader classLoader = 对象.getClass().getClassLoader();
Class cls4 = classLoader.loadClass(“类的全类名”);
5、基本数据(int,char,boolean,float,double,byte,long,short)按如下方式得到Class类对象
Class cls5 = 基本数据类型.class
6、基本数据类型对应的包装类,可以通过 .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);
}
}
反射机制是 Java 实现动态语言的关键,也就是通过反射实现类动态加载
Dog dog = new Dog();
Class cls = Class.forName("Person");
Object o = cls.newInstance();
Method method = cls.getMethod("hi");
method.invoke(o);
JVM在改阶段的主要目的是将字节码从不同的数据源(可能是 class 文件、也可能是 jar 包,甚至网络)转化为二进制字节流加载到内存中,并生成一个代表该类的 java.lang.Class 对象
JVM 会在该阶段对静态变量,分配内容并初始化(对应数据类型的默认初始值,如0、0L、null、false等)。这些变量所使用的内存都将在方法区中进行分配
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;
}
虚拟机将常量池内的符号引用替换为直接引用的过程。
到初始化阶段,才真正开始执行类中定义的 Java 程序代码,此阶段是执行<clinit>()方法的过程
@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
**/
Class类相关方法
Constructor类相关方法
package com.jwt.reflection;
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 + "]";
}
}
Field f = class对象.getDeclaredField(属性名);
f.setAccessible(true); //f是Field
f.set(o,值); //o表示对象
f.get(o); //o表示对象
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 + "]";
}
}
Method m = class对象.getDeclaredMethod(方法名,XX.class);
Object o = class对象.newlnstance();
m.setAccessible(true);
Object returnValue = m.invoke(o,实参列表);
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 完成以下功能
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("创建成功");
}
}