反射
反射是框架设计的灵魂
1. 定义
- JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法
- 对于任意一个对象，都能够调用它的任意一个方法和属性
- 这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制
- 要想解剖一个类,必须先要获取到该类的字节码文件对象
- 而解剖使用的就是Class类中的方法，所以先要获取到每一个字节码文件对应的Class类型的对象
例子
import java.lang.reflect.Method;
public class Demo1_refiect {
public static void main(String[] args) throws Exception {
Demo1_person person = new Demo1_person();
person.setName("小刘");
person.setAge(18);
System.out.println(person);
// 1.通过反射的方式，创建Demo1_person类的对象，并调用对象的setName方法，参数是小刘
Class<?> cls1 = Class.forName("com.day22.Demo1_person");
Object obj = cls1.newInstance();
// 动态获取这个类的所有方法
Method[] methods = cls1.getMethods();
for (Method method : methods) {
System.out.println(method);
}
Method method = cls1.getMethod("setName", String.class);
System.out.println("单个获取："+method);
// invoke(Object obj, Object...args)
// 对带有指定参数的指定对象调用由此Method对象表示的底层方法
method.invoke(obj, "小龚");
System.out.println(obj);
}
}
public class Demo1_person {
public String sex;
private String name;
private 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 "Demo1_person [name=" + name + ", age=" + age + "]";
}
}
Class对象
Class对象用于描述一个正在运行的类或接口。如果类或接口被加载进内存了，内存中肯定会有该类的Class对象。
- 如何获取类的Class对象
方式一：通过类的class属性来获得
Class cls = Person.class;
方式二：通过类的对象的getClass()方法来获得
Person p = new Person();
Class cls = p.getClass();
方式三：通过Class的静态方法forName(完整类名)来获得
Class<?> cls = Class.forName("com.xxx.Person");
例子
public class Demo2 {
public static void main(String[] args) throws ClassNotFoundException {
// 获取对象的三种方式
// 方式一：通过类的class属性来获得
Class<?> cls1 = Demo1_person.class;
System.out.println(cls1);
// 方式二：通过类的对象的getClass()方法获得
Demo1_person p = new Demo1_person();
Class<?> cls2 = p.getClass();
System.out.println(cls2);
// 方式三：通过forName方式获得
Class<?> cls3 = Class.forName("com.day22.Demo1_person");
System.out.println(cls3);
}
}
- 如何使用Class对象来创建类的对象
使用newInstance()方法来创建对象（Class类的newInstance()方法是使用该类无参的构造函数创建对象）
例子
Object object = cls3.newInstance();
System.out.println(object); // Demo1_person [name=null, age=0]
Constructor构造器
- 获得一个类的Constructor对象
| 方法 | 描述 |
|---|---|
| getConstructors() | 获得类中所有的构造器 |
| getConstructor(Class...parameterTypes) | 获得类中指定的构造器 |
例子
import java.lang.reflect.Constructor;
public class Demo5_constructor {
public static void main(String[] args) throws Exception {
Class<?> cls = Class.forName("com.day22.Demo3_teacher");
// 获取Demo3_teacher类中所有的构造方法
Constructor<?>[] constructors = cls.getConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println(constructor);
}
// 获取指定的构造方法
Constructor<?> constructor = cls.getConstructor(String.class, int.class);
}
}
- 通过Constructor创建对象
newInstance(Object...args)
// 单参数的 newInstance(Object ... initargs) Object ... initargs===可变参数
Object obj = constructor.newInstance("小刘", 22);
System.out.println(obj);
// 打印输出
Demo3_teacher [teacherName=小刘, teacherAge=22]
Field: 通过反射来操作一个类的属性
- 获得Filed对象
| 方法 | 描述 |
|---|---|
| getField(String fieldName) | 获得指定字段的Field对象 |
| getFields() | 获得所有字段（父类公共的，子类公共的）的Field对象数组 |
| getDeclaredField(String fieldName) | 获得指定字段的Field对象（只有子类的，不包含父类的，包含私有的）的Field对象 |
| getDeclaredFields() | 获得所有字段（只有子类的，不包含父类的，包含私有的）的Field对象数组 |
例子
public class Demo3_teacher extends Demo1_person {
public String teacherName;
private int teacherAge;
}
import java.lang.reflect.Field;
public class Demo3_test {
public static void main(String[] args) throws Exception {
Class<?> cls = Class.forName("com.day22.Demo3_teacher");
// 获取指定字段的Field对象
Field f = cls.getField("teacherName");
System.out.println(f);
// 获得Teacher类中的所有字段（父类公共的，子类公共的）的Filed对象数组——属性
// 假如Teacher父类中有一个Sex属性，getFields()也能获取
Field[] fields = cls.getFields();
for (Field field : fields) {
System.out.println(field);
}
// 获取指定字段的Field对象（有子类的，不包含父类的，包含私有的Field对象）
Field df = cls.getDeclaredField("teacherAge");
System.out.println(df);
// 获得所有字段（只有子类的，不包含父类的，包含私有的）的Field对象数组——属性
fields = cls.getDeclaredFields();
for (Field field : fields) {
System.out.println(field);
}
}
}
// 打印输出
public java.lang.String com.day22.Demo3_teacher.teacherName
public java.lang.String com.day22.Demo3_teacher.teacherName
public java.lang.String com.day22.Demo1_person.sex
private int com.day22.Demo3_teacher.teacherAge
public java.lang.String com.day22.Demo3_teacher.teacherName
private int com.day22.Demo3_teacher.teacherAge
- 通过Field对象为属性赋值
set([Object obj,Object value)
将指定对象变量上此Field对象表示的字段设置为指定的新值。
例子
// 获得Teacher类中的名字属性 teacherName
Field ft = cls.getField("teacherName");
// 先创建对象
Object obj = cls.newInstance();
ft.set(obj, "小刘");
System.out.println(obj);
Method:操作类中的方法
- 获得Method对象
| 方法 | 描述 |
|---|---|
| getMethods() | 获取类中所有的公共方法，包括父类的公共方法 |
| getMethod(String methodName, Class...parametersType) | 获取类中指定的方法，公共的，包括父类的公共的方法 |
| getDeclaredMethods() | 获取本类的所有的方法，包括私有的 |
| getDeclaredMethod(String methodName, Class... parametersType) | 获取本类的指定的方法，可以是私有的 |
例子
import java.lang.reflect.Method;
public class Demo4_method_test {
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
Class<?> cls = Class.forName("com.day22.Demo3_teacher");
// 获得类中所有的公共的，包括父类的公共方法
Method[] methods = cls.getMethods();
for (Method method2 : methods) {
System.out.println(method2);
}
// 获得类中指定的公共的方法，包括父类的公共方法
/**
* @param name 指定的方法名字
* @param parameterTypes 指定的方法名的参数类对象，可以写多个
* */
Method method3 = cls.getMethod("eat", String.class, Integer.class);
System.out.println(method3);
// 获取本类中的所有方法包括私有的方法
Method[] dms = cls.getDeclaredMethods();
for (Method method : dms) {
System.out.println(method);
}
// 获得本类中指定的方法，可以是私有的
/**
* @param name 指定的方法名字
* @param parameterTypes 指定的方法名的参数类对象，可以写多个，如果要查找的方法没有参数，不写
* */
Method method4 = cls.getDeclaredMethod("show");
System.out.println(method4);
}
}
- Method方法的调用
使用invoke()方法进行调用
method.invoke(被调用方法的对象，实参列表)
例子
// Method方法的调用
Class<?> clsm = Class.forName("com.day22.Demo3_teacher");
// 获取指定的某个方法
Method method5 = clsm.getMethod("eat", String.class, int.class);
//先需要有Teacher对象
Object obj = clsm.newInstance();
// 方法的调用
method5.invoke(obj, "小刘", 18 ); // 输出teacher public eat(String a, int b) function
反射案例
- 通过反射，越过泛型检查
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
public class Demo7_overriding_generics {
// 通过反射越过泛型检查
public static void main(String[] args) throws Exception {
List<String> list = new ArrayList<>();
list.add("小刘");
// list.add(123); // 编译错误
Class<?> cls = Class.forName("java.util.ArrayList");
Method method = cls.getMethod("add", Object.class);
// 通过invoke方法，method可以调用list中的方法
method.invoke(list, 123);
System.out.println(list); // 打印输出[小刘, 123]
}
}
我们使用泛型就是为了使运行时错误提前到了编译期，而使用反射，我们可以在运行时期将不相同的元素写入List集合，这就是通过反射越过泛型检查
- Properties类的使用
Properties是描述一个属性集（键值对），它是一个Hashtable，可以通过Properties来读取外部文件存放的键值对。
例子
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;
public class Demo8_properties {
public static void main(String[] args) throws IOException {
// 1.创建Properties对象
Properties properties = new Properties();
// 2. 加载配置文件到properties中
properties.load(new FileInputStream("src/com/day22/info.properties"));
// 获取外部文件中的键值对
System.out.println(properties.getProperty("name"));
}
}
