反射机制
反射机制
反射机制是什么
1.反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；
2.对于任意一个对象，都能够调用它的任意一个方法和属性；
3.这种动态获取的信息以及动态调用对象的方法的功能就是反射机制；
4.也就是说通过反射机制，我们可以获取想要获取到的东西，对前面所学到的范围限定词的限制就可以打破约束
反射机制的作用
1.在运行时判断任意一个对象所属的类；
2.在运行时构造任意一个类的对象；
3.在运行时判断任意一个类所具有的成员变量和方法；
4.在运行时调用任意一个对象的方法；
5.生成动态代理；
反射机制的使用
由于反射机制操作的是类的字节码文件对象，所以想要使用反射机制就必须获取到该类的字节码文件，获取类的字节码文件有3种操作方式
1.通过Class类中的静态方法forName（）；可以获取到字节码对象
Class class1 = class.forName("包名.类名")
2.直接用该类.class获取字节码文件对象
Class class2 = Dog.class;
3.通过类的实例获取该类的字节码文件对象
Class class3 = new Dog().getClass();
getDeclaredFields 和 getFields 的区别
- getDeclaredFields()获得某个类的所有申明的字段，即包括public、private和proteced，但是不包括父类的申明字段。
- getFields()获得某个类的所有的公共（public）的字段，包括父类。
获取类中的信息
import java.lang.reflect.Field;
class Person extends Human{
public int age;
private String name;
protected long id;
}
class Human{
public int hight;
}
public class Main{
public static void main(String[] args) {
Class class1 = Person.class;
Field[] f1 = class1.getFields();//获取到所有被public修饰的类信息，包括父类中的
for(Field f:f1)
System.out.println(f);
Field[] f2 = class1.getDeclaredFields();//获取到本类中所有类的信息
for(Field f:f2)
System.out.println(f);
}
}
获取指定的类属性对象
import java.lang.reflect.Field;
class Person extends Human{
public int age;
private String name;
protected long id;
}
class Human{
public int hight;
}
public class Main{
//因为存在访问不到的可能，所以需要抛出异常
public static void main(String[] args)throws Exception {
Class class1 = Person.class;
Field f1 = class1.getField("age");//只能获取父类及本类被public修饰的类属性
Field f2 = class1.getDeclaredField("name");//可以任意获取本类中的指定类属性
System.out.println(f1);
System.out.println(f2);
}
}
获取构造方法信息
import java.lang.reflect.Constructor;
class Person extends Human {
public int age;
private String name;
protected long id;
public Person(int age, String name, long id) {
this.age = age;
this.name = name;
this.id = id;
}
public Person() {
}
private Person(int age, String name) {
this.age = age;
this.name = name;
}
}
class Human {
public int hight;
}
public class Main {
public static void main(String[] args) throws Exception {
Class class1 = Person.class;
Constructor[] c1 = class1.getConstructors();//获取所有被public修饰的构造器
for (Constructor c : c1)
System.out.println(c);
System.out.println("--------------");
Constructor[] c2 = class1.getDeclaredConstructors();//获取本类所有的构造器
for (Constructor c : c2)
System.out.println(c);
}
}
获取指定的构造方法
import java.lang.reflect.Constructor;
class Person extends Human {
public int age;
private String name;
protected long id;
public Person(int age, String name, long id) {
this.age = age;
this.name = name;
this.id = id;
}
public Person() {
}
public Person(int age) {
}
private Person(int age, String name) {
this.age = age;
this.name = name;
}
}
class Human {
public int hight;
}
public class Main {
public static void main(String[] args) throws Exception {
Class class1 = Person.class;
Constructor c1 = class1.getConstructor(null);//无参构造器
System.out.println(c1);
Constructor c2 = class1.getConstructor(int.class);//有参构造器
System.out.println(c2);
System.out.println("--------------");
Constructor c3 = class1.getDeclaredConstructor(int.class,String.class);
System.out.println(c3);
}
}
获取方法的信息
import java.lang.reflect.Method;
class Person extends Human {
public int age;
private String name;
protected long id;
public Person(int age, String name, long id) {
this.age = age;
this.name = name;
this.id = id;
}
public Person() {
}
public Person(int age) {
}
private Person(int age, String name) {
this.age = age;
this.name = name;
}
public void aa() {
}
private void bb() {
}
private void cc() {
}
}
class Human {
public int hight;
}
public class Main {
public static void main(String[] args) throws Exception {
Class class1 = Person.class;
//获取到本类被public修饰以及父类中被public修饰的方法
Method[] m1 = class1.getMethods();
for(Method m : m1)
System.out.println(m);
System.out.println("------------");
Method[] m2 = class1.getDeclaredMethods();//获取到本类中所有的方法
for(Method m : m2)
System.out.println(m);
}
}
获取指定方法的信息
import java.lang.reflect.Method;
class Person extends Human {
public int age;
private String name;
protected long id;
public Person(int age, String name, long id) {
this.age = age;
this.name = name;
this.id = id;
}
public Person() {
}
public Person(int age) {
}
private Person(int age, String name) {
this.age = age;
this.name = name;
}
public void aa() {
}
private void bb(int x) {
System.out.println("bb方法");
}
private void cc() {
}
}
class Human {
public int hight;
public void oo() {
}
}
public class Main {
public static void main(String[] args) throws Exception {
Class class1 = Person.class;
Method m1 = class1.getMethod("aa");//只能获取本类及父类中被public修饰的方法
System.out.println(m1);
//可以获取本类中所有任意指定的方法
Method m2 = class1.getDeclaredMethod("bb", int.class);
System.out.println(m2);
}
}
对反射机制的使用
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
class Person extends Human {
public int age;
private String name;
protected long id;
public Person(int age, String name, long id) {
this.age = age;
this.name = name;
this.id = id;
}
public Person() {
}
public Person(int age) {
}
private Person(int age, String name) {
this.age = age;
this.name = name;
}
public void aa() {
}
private void bb(int x) {
System.out.println("bb方法");
}
private void cc() {
}
public static void dd() {
}
}
class Human {
public int hight;
void oo() {
}
}
public class Main {
public static void main(String[] args) throws Exception {
Class class1 = Person.class;
Object obj = class1.newInstance();
//使用无参的构造方法创建对象
System.out.println(obj);
Constructor constructor1 =
class1.getDeclaredConstructor(int.class,String.class);
constructor1.setAccessible(true);
Object dog = constructor1.newInstance(10,"aa");
System.out.println(dog);
Field name = class1.getDeclaredField("name");
name.setAccessible(true);
name.set(dog, "张三");
//获取dog对象的name属性的值
System.out.println(name.get(dog));
Method aa = class1.getMethod("aa");
//调用了dog对象的aa方法
aa.invoke(dog);
Method bb = class1.getDeclaredMethod("bb", int.class);
bb.setAccessible(true);
//静态方法将第一个参数设置为null
bb.invoke(dog, 10);
Method dd = class1.getDeclaredMethod("dd");
dd.invoke(null);
System.out.println(dd);
}
}