反射机制
概述
编程可以分为动态语言和静态语言,我们常见的动态语言有PHP,C#,JavaScript
静态语言就是 Java c/c++
所谓的动态语言,就是可以在它运行的时候,来做出一些操作,可以修改它的执行内容
而反射机制的加入,使Java成为了一个准动态语言
本文内容
- 获取对象
- 获取构造器
- 获取属性
- 获取方法
- 给属性赋值
- 调用方法
获得对象
反射机制如何获取一个对象???,我们在pojo包下新建一个Test类
package live.fanxing.reflection.pojo;
public class Test {
String name;
int 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;
}
@Override
public String toString() {
return "Test{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
Class.forName()
通过包的路径来获取一个类
Class test1 = Class.forName("live.fanxing.reflection.pojo.Test");
.Class()
根据一个类名后面跟 .class可以获取到
Test.class
.getClass
把这个class创建一个新的实例,然后通过getClass方法来获取
new Test().getClass()
然后我们测试一下
package live.fanxing.reflection;
import live.fanxing.reflection.pojo.Test;
public class Reflection01 {
public static void main(String[] args) throws ClassNotFoundException {
test();
}
static void test() throws ClassNotFoundException {
System.out.println(Class.forName("live.fanxing.reflection.pojo.Test"));
System.out.println(new Test().getClass());
System.out.println(Test.class);
}
}
可以看到,我们通过这三种方法获取到了,但是我们发现打印出来的结果都是一样的,这说明了说明??
在java中,不管是创建的实例还是什么,它只有一个Class保存到了堆中,创建实例,反射获取,静态获取都是获取的这个class
获取构造器
首先,我们在Test类上加两个构造器,一个无参,一个有参,一个public,一个private
public Test(){
}
private Test(String name,int age){
this.name = name;
this.age = age;
}
获取全部构造器
Class对象中给我们提供了两个常用的方法来获取构造器 getConstructors()和getDeclaredConstructors()
使用 getConstructors()会获取到当前类的全部为public类型的构造器
使用getDeclaredConstructors() 会获取到当前类的全部构造器,包括private和public
我们下面写代码来测试一下看看
Class test1 = Class.forName("live.fanxing.reflection.pojo.Test");
Constructor[] constructors = test1.getConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
Constructor[] constructors1 = test1.getDeclaredConstructors();
for (Constructor constructor : constructors1) {
System.out.println("declared:"+constructor);
}
在看下运行的结果
我们看到上方的图片,可以看出来,第一个循环只打印了public类型的无参构造器,第二个循环打印出来了 无参和有参
获取指定构造器
获取指定构造器,根据构造器的参数样式来获取构造器,可以使用getConstructor()和getDeclaredConstructor()
这两个方法其实和上面的区别一样,一个获取public,一个获取全部
这两个方法里面有个parameterTypes参数,为什么要有参数呢??
想想我们有参和无参构造器是用什么区别的,参数个数,和参数的类型,这个参数是让我们传入它这些构造器的参数的类型
用代码来演示下,我们用getConstructor()测试下
Constructor constructors = test1.getConstructor(null); //这一行是获取到的是无参构造器,因为它里面没有任何参数,所以我们填入null
Constructor constructors1 = test1.getConstructor(String.class,int.class);//这个是获取到有参构造器的,我们有参构造器里有两个参数,一个是String类型的一个是int类型的,所以我们传入String.class,int.class,如果是其他类型的话,就传入其它的那个类型就行
我们看下打印的截图
我们可以看到报错了,报错的行数在第25行,也就是获取到有参构造器的时候,不要忘了,我们的有参构造器是私有的,这个
getConstructor()方法是获取不到私有的,我们把第25行改成下面的代码
Constructor constructors1 = test1.getDeclaredConstructor(String.class,int.class);
然后我们加两个打印,把constructors和constructors1打印到控制台,在看看
获取属性
获取全部属性
获取属性也有Declared和不加Declared区分,通过上面获取构造器,我们也可以很快的认识到getFields()和getDeclaredFields()的区别
我们将Test类中的 name属性改成public类型的
public String name;
int age;
然后在用这两个方法获取的属性然后进行遍历
Field[] fields = test1.getFields();
Field[] fields1 = test1.getDeclaredFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("========");
for (Field field : fields1) {
System.out.println(field);
}
然后我们在查看打印到控制台的效果
获取指定属性
获取指定的属性也就是把上面获取全部属性的方法最后的s给去掉就行,然后会有一个name的参数,我们应该填写这个属性的名称,比如说获取name
因为name是public类型的,getField() 方法也可以获取到
Field field = test1.getField("name");
Field field1 = test1.getDeclaredField("name");
System.out.println(field);
System.out.println("field1:"+field1);
System.out.println("================");
//但是我们在试试获取到age,我们调整下顺序,把declared的方法放上面,不加这个的那个方法肯定会报错
Field field3 = test1.getDeclaredField("age");
System.out.println("field3:"+field3);
Field field2 = test1.getField("age");
System.out.println("field2:"+field2);
获取方法
获取全部方法
获取方法也和上方一样,有declared的区别,它也有两个方法 ,只不过这两个方法的区别与上面有相同处也有不同处
Method[] method = test1.getMethods();
for (Method method1 : method) {
System.out.println(method1);
}
System.out.println("================");
Method[] methods = test1.getDeclaredMethods();
for (Method method1 : methods) {
System.out.println(method1);
}
看下控制台图片
getMethods()方法会把父类的所有public方法也一块获取到,但是所有的private方法是获取不到的
getDeclaredMethods() 会获取到本类中的所有方法,包括private
获取指定方法
Method method = test1.getMethod("TestFather",null); //取父类
Method method1 = test1.getMethod("setName",String.class);//取当前类中的public方法
Method method2 = test1.getDeclaredMethod("setAge",int.class); //取本类中的公有方法
System.out.println(method);
System.out.println(method1);
System.out.println(method2);
用反射创建一个实例
创建实例我们需要使用到newInstance()方法,我们还用上方的test1这个Class对象,用它来创建一个Test的实例
直接用Class对象创建
Test a = (Test) test1.newInstance();
System.out.println(a);
使用构造器来创建
使用 Class对象直接创建的话,我们可以看到输出的name为null,这说明它使用了无参构造器的方法来创建了,那么我们怎么用有参构造器来创建??
// 1.先获取到它的构造器,
Constructor constructors1 = test1.getDeclaredConstructor(String.class,int.class);
System.out.println(constructors1);
// 2.用这个构造器来创建一个实例
Test b = (Test)constructors1.newInstance("fanxing",18);
System.out.println(b);
然后我们看下这两种办法打印的结果
用反射给属性赋值
上面一步我们已经创建好新的实例了,我们这次使用构造器创建的实例,把它的age给改了
Test b = (Test)constructors1.newInstance("fanxing",18);
System.out.println(b);
Field field = test1.getDeclaredField("age");
field.setInt(b,20);
System.out.println(b.getAge());
可以看到报错了,无法访问类的成员变量。
我们在赋值前,我们加一行代码
field.setAccessible(true);
Constructor constructors1 = test1.getDeclaredConstructor(String.class,int.class);
System.out.println(constructors1);
Test b = (Test)constructors1.newInstance("fanxing",18);
System.out.println(b);
Field field = test1.getDeclaredField("age");
field.setAccessible(true);
field.setInt(b,20);
System.out.println("修改后的年龄为:" + b.getAge());
然后在看下结果
用反射执行方法
本篇最后的内容,通过反射来调用方法
invoke : 执行当前的方法
Method method = test1.getDeclaredMethod("setAge",int.class); //获取方法
System.out.println("执行setAge:" + method.invoke(b, 190)); //执行,invoke的参数:第一个是用于哪个实例,后面是它这个方法中的参数,按顺序
Method method1 = test1.getDeclaredMethod("getAge",null); //因为 getAge没有参数,所以后面的用null
System.out.println("执行getAge:"+ method1.invoke(b,null));