反射
**定义:**在运行期间,可以期间可以获得对象的类型,类型的方法、类型的属性、类型的构造方法等等,让对象可以认识自身的结构
获取对象的类型(类对象)
方式1: Object.getClass()
方式2: Class.forName(“类名”)
方式3: 类名.class
类对象的功能
1)用反射的方式创建对象
正常创建对象: new 类名();
反射创建对象: 类对象.newInstance();//创建一个新实列(对象)
2)获取方法信息
类对象.getMethod(); //获取所有公共方法(public),包括继承的
类对象.getDeclaredMethods();//获取本类的所有方法,报货私有
类对象.getMethod(方法名,参数类型);
类对象.getDeclaredMethods(方法名参数类型);
3)获取属性信息
类对象.getFields();获取所有公共属性,包括继承
类对象.getDeclaredFields(); // 获取本类所有属性(private public protected 不加)(不包括继承的)
类对象.getField(“属性名”);
类对象.getDeclaredField(“属性名”);
4)获取构造方法
类对象.getConstructors();获取所有公共的构造方法,包括继承
类对象.getDeclaredConsttructors()//获取本类的构造方法包括私有
类对象.getConstructor(int.class); // 获取int参数类型的构造
类对象.getConstructor(); // 获得无参构造
5)反射调用方法
正常调用方式:对象.invoke(对象,参数)
反射调用方式:方法.invoke(对象,参数)
缺点:调用复杂,效率低
优点:可以调用私有方法,突破正常方法的限制,(经常在开源框架中)
补充:
1、//反射创建对象,newInstance()限制1:要求对象有无惨构造 限制2:构造方法不能私有
2、 m1.setAccessible(true); 、、私有方法要经过 方法.setAccessible(true);默认为false要设置为true才能使用
package src.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class TestReflect {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
// 方法1
// System.out.println(new User().getClass());
// 方法2
System.out.println(Class.forName("reflect.User"));
// 这个类型信息在jvm仍表现为一个对象,而且只有一份
// System.out.println(new User().getClass() == Class.forName("reflect.User"));
// 方法3
System.out.println(User.class);
// 反射创建对象, newInstance() 限制1: 要求对象有无参构造 限制2: 构造方法不能私有
User user = User.class.newInstance();
System.out.println(user);
// 获取方法信息
Method[] methods = User.class.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method);
}
System.out.println("============================");
// Method m = User.class.getMethod("m1");
// System.out.println(m);
System.out.println("============================");
Field[] fields = User.class.getFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("=============================");
User u = new User();
// u.m1(); // 正常调用方法
// 方法.invoke(对象, 参数);
Method m1 = User.class.getDeclaredMethod("m1");
m1.setAccessible(true); // 设置这个方法可以被访问,可以突破访问修饰符的限制
m1.invoke(u); // 反射调用方法(性能低)
// 反射调用 public void m1(int a)
Method m12 = User.class.getDeclaredMethod("m1", int.class);
m12.invoke(u, 1);
Method m13 = User.class.getDeclaredMethod("m1", int.class, int.class);
m13.invoke(u, 4, 5);
// 调用私有构造
Constructor<Student> cons = Student.class.getDeclaredConstructor();
cons.setAccessible(true);
Student s = cons.newInstance();
System.out.println(s);
}
}