1.什么是反射
指程序可以访问，检测和修改它本身状态或行为的一种能力，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。
反射是java中一种强大的工具，能够使我们很方便的创建灵活的代码，这些代码可以再运行时装配，无需在组件之间进行源代码链接。但是反射使用不当会成本很高！
反射提供了一种机制——用来检查可用的方法,并返回方法名.
人们想要在运行时获取类的信息的另一动机,便是希望提供在跨网络的远程平台上创建和运行类的能力.
——《Think In Java》第四版
反射用来干什么?
通过class文件对象:
- 使用该文件的成员变量
- 使用该文件的构造方法
- 使用该文件的成员方法
1.用反射获取class对象
//先准备一个Person类
package cn.lawfree_01;
public class Person {
private String name;
int age;
public String address;
//写四种构造方式
public Person() {}
private Person(String name) {this.name = name;}
Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
public void show() {
System.out.println("show");
}
public void method(String s) {
System.out.println("method " + s);
}
public String getString(String s, int i) {
return s + "---" + i;
}
private void function() {
System.out.println("function");
}
@Override
public String toString() {
return "姓名:" + name + " 年龄:" + age + " 地址:" + address;
}
}
/**
* 反射:就是通过class文件对象,去使用该文件的成员变量,构造方法
*
* 通过class对象去干其他事儿,首先就必须得到class文件独享,其实也就是得到Class类的对象
* (Class类:
* 成员变量 Filed
* 构造方法 Constructor
* 成员方法 Method)
*
* 获取class对象的方式有三种:
* A:Object类的getClass()方法
* B:数据类型的静态属性class
* C:Class类中的静态方法
* public static Class<?> forName(String className)
*
* 一般选用哪一个?
* A:自己玩 任选一种,第二种比较方便
* B:开发 第三种
* 为什么?因为第三种是一个字符串,而不是一个具体类名,这样我们就可以把这样的字符串配置到配置文件中
*/
public class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException {
// 方式1:Object类的getClass()方法
//先获得一个示例对象的引用p
Person p = new Person();
//通过p.getClass获得
Class c = p.getClass();
Person p2 = new Person();
Class c2 = p.getClass();
System.out.println(p == p2);// false//由于示例化了两个对象,c和c2分别指向两个不同的对象,这点很好理解
System.out.println(c == c2);// true//注意这里实际上获得的同一个class对象(字节码对象)`
// 方式2,直接用类型名称.class 来获得
Class c3 = Person.class;
// int.class;
// String.class;
System.out.println(c == c3);//当然还是一样的啦~
// 方式3,Class.forName(类型的权限名)
// ClassNotFpundException
// cn.lawfree_01.Person
Class c4 = Class.forName("cn.lawfree_01.Person");
System.out.println(c == c4);//依然是一样
}
}
1.2通过反射获取构造方法并使用
public class ReflectDemo {
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("cn.lawfree_01.Person"); // 好处就是:将来这里配的是谁,运行的就是睡
// 获取构造方法(组)
//1.使用getConstructors()获得所有公共构造方法
// public Constructor[] getConstructors()
//2.使用getDeclaredConstructors()获得所有构造方法
// public Constructor[] getDeclaredConstructors()
Constructor[] cons = c.getDeclaredConstructors();
for (Constructor con : cons) {
System.out.println(con);
}
/*
*private cn.lawfree_01.Person(java.lang.String)
*cn.lawfree_01.Person(java.lang.String,int)
*public cn.lawfree_01.Person(java.lang.String,int,java.lang.String)
*public cn.lawfree_01.Person()
*
*/
// 获取单个构造方法
// public Constructor<T> getConstructor(Class<?>... parameterTypes)
// 参数表示的是:你要获取的构造方法的构造参数个数及数据类型的class字节码文件对象.比如:
Constructor con = c.getConstructor();// 返回的是构造方法对象
// Person p=new Person();
// System.out.println(p);
// public T newInstance(Object... initargs)
// 使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
Object obj = con.newInstance();//这样构造哦!
System.out.println(obj);
}
}
把前面的结合运用一下:
public class ReflectDemo2 {
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("cn.lawfree_01.Person");
// 获取带参构造器
Constructor con = c.getConstructor(String.class, int.class,
String.class);
// 通过带参构造方法创建对象
// public T newInstance(Object... initargs)
Object obj = con.newInstance("lawfree", 20, "成都");
System.out.println(obj);//姓名:lawfree 年龄:21 地址:成都
}
}
这里再看一个例子:
import java.lang.reflect.Constructor;
/*
* 需求:通过反射获取私有构造方法并使用
* private Person (String name)
* Person p=new Person("lawfree");//这显然是不行的
*
*/
public class ReflectDemo3 {
public static void main(String[] args) throws Exception {
// 获取字节码对象
Class c = Class.forName("cn.lawfree_01.Person");
// 获取私有构造方法
// java.lang.NoSuchMethodException
// Constructor con = c.getConstructor(String.class);// 这个方法只能拿public公共的
Constructor con2 = c.getDeclaredConstructor(String.class);
// java.lang.IllegalAccessException,非法的访问异常
// 暴力访问
con2.setAccessible(true);// 值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。。这样就可以用getDeclaredConstructor(String.class)找到合适的构造方法
// 用该私有方法创建对象
Object obj = con2.newInstance("lawfree");
System.out.println(obj);
}
}
1.3通过反射获得成员变量并使用
public class ReflectDemo {
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("cn.lawfree_01.Person");
// 获取所有成员变量
// Field[] fields = c.getFields();还是只能获取公共的
// Field[] fields = c.getDeclaredFields();
// for (Field field : fields) {
// System.out.println(field);
// }
/*
*我们以前这样做的:
* Person p=new Person(); p.address="成都"; System.out.println(p);
*/
// 通过无参构造创造对象
Constructor con = c.getConstructor();
Object obj = con.newInstance();
// 获取单个的成员变量并赋值
Field addressField = c.getField("address");
// public void set(Object obj, Object value)
// 将制定对象变量上此Field对象表示的字段设置为新值
addressField.set(obj, "成都");// 给obj对象的addressField字段设置值为为"成都"
System.out.println(obj);
// 获取name并对其赋值
// java.lang.NoSuchFieldException(因为他不是公共的)
// Field nameField = c.getField("name");
Field nameField = c.getDeclaredField("name");
// java.lang.IllegalAccessException
nameField.setAccessible(true);// 可以访问
nameField.set(obj, "lawfree");
System.out.println(obj);
// 获取age并对其赋值
Field ageField = c.getDeclaredField("age");
ageField.setAccessible(true);
ageField.set(obj, 21);
System.out.println(obj);
}
}
1.3通过反射获得成员方法并使用
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class ReflectDemo {
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("cn.lawfree_01.Person");
// 获取所有的方法
// Method[] methods = c.getMethods();//获取自己的包括父类的public方法
// Method[] methods = c.getDeclaredMethods();//获取自己的所有方法
// for (Method method : methods) {
// System.out.println(method);
// }
Constructor con = c.getConstructor();
Object obj = con.newInstance();
/*
* 以前我们这么用:
* Person p=new Person(); p.show();
*/
// 获取单个方法并使用
// public void show()
// public Method getMethod(String name,Class<?>... parameterTypes)
// 第一个参数表示方法名,第二个表示方法的class类型
Method m1 = c.getMethod("show");
// obj.m1();
// public Object invoke(Object obj, Object... args
// 返回值是Object,第一个数据表示对象是谁,第二个表示调用该方法的实际参数
m1.invoke(obj);// 调用obj对象的,1方法
System.out.println("------------");
// public void method(String s)
Method m2 = c.getDeclaredMethod("method", String.class);
m2.invoke(obj, "hello");
System.out.println("------------");
// public String getString(String s, int i)
Method m3 = c.getDeclaredMethod("getString", String.class, int.class);
// Object objString = m3.invoke(obj, "hello", 100);
// System.out.println(objString);
String s = (String) m3.invoke(obj, "hello", 100);
System.out.println(s);
System.out.println("------------");
// private void function()
Method m4 = c.getDeclaredMethod("function");
m4.setAccessible(true);
m4.invoke(obj);
//输出结果:
// show
// ------------
// method hello
// ------------
// hello---100
// ------------
// function
}
}
