Der Reflexionsmechanismus befindet sich im laufenden Zustand. Er bietet Java die Möglichkeit, über das Klassendateiobjekt die Eigenschaften, Methoden und Konstruktoren in jeder Klasse, einschließlich privater, aufzurufen Ja, alle Klassen sind vor dem Reflexionsmechanismus transparent
Meine eigene Zusammenfassung: Sie können alles in dieser Klasse über das Klassendateiobjekt sehen und es verwenden und ändern
Die Voraussetzung der Reflexion besteht darin, das zu erhalten Klassendateiobjekt ((Bytecode-Objekt), dann gibt es drei Möglichkeiten, es zu erhalten:
Class.forName ("vollständiger Klassenname") ---- über die statische Methode der Klassenklasse (am häufigsten verwendet)
Klasse Name.class
Object.getClass()
//方式1：获取字节码对象，Class.forName("全类名")
Class cla1 = Class.forName("Study01.Person");
//方式2: 类名.Class
Class cla2 = Person.class;
//方式3：对象.getClass();
Person per = new Person();
Class cla3 = per.getClass();
//这三个class对象都是由Person这个类生成的
//那么我们看一下这三个字节码对象是不是同一个：
System.out.println(cla1==cla2);
System.out.println(cla2==cla3);//Ausgabeergebnisse: Zwei wahre
Schlussfolgerung:
Das Bytecode-Objekt wird generiert, wenn die Klasse geladen wird, und Es gibt nur eines
Egal auf welchem Weg das Bytecode-Objekt abgerufen wird, es ist dasselbe Bytecode-Objekt
Erhalten Sie die Attribute in der Klasse durch Reflektion:
Nachdem wir das Klassen-Bytecode-Objekt erhalten haben, können wir das verwenden Word-Abschnittscodeobjekt, um die Attribute, Methoden, Konstruktoren und privaten Modifikationen der Klasse zu erhalten, die wir erhalten möchten.
Teil der Klassenmethoden:
1 Zwei öffentliche und zwei private Attribute (ohne Einstellungskonstruktion und Get/Set, schauen Sie einfach, ob die Reflexion den Wert in sich aufnehmen kann)
public class Person {
private String name; //名字
private int age = 18; //年龄
public int ID = 123; //身份证
public String Sex; //性别
@Override
public String toString(){
return "姓名"+name+"年龄："+age+"ID："+ID+"性别："+Sex;
}
}Testklasse:
public class Test {
public static void main(String[] args) throws ClassNotFoundException {
//获取Class文件对象，用最常用的通过Class类的静态方法
Class per = Class.forName("Test01.Person"); //这里是传入全路径！！从最外层的包名开始！
//使用getFields()方法获取全部被public修饰的属性（方法上面的截图有）
//并且返回的是Field类型的数组
Field fields[] = per.getFields();
for (Field field:fields) {
System.out.println(field);
}
}
}Ausgabe:
Wir haben alle öffentlichen Attribute der Person-Klasse erfolgreich erhalten
2. Sie können auch alle Attribute abrufen, einschließlich privater: (Andere Codes werden nicht neu geschrieben)
for (Field field : per.getDeclaredFields()) {
System.out.println(field);
}Ausgabe:
3. Öffentliche Attribute abrufen und den Wert ändern:
Field f = per.getField("Sex");
System.out.println(f);
//获取一个对象：
Object obj = per.getConstructor().newInstance();
//修改值：
f.set(obj,"男");
Person p = (Person)obj;
System.out.println(p.Sex);Ausgabe:
4. Holen Sie sich das private Attribut und ändern Sie den Wert: Verbinden Sie hier auch die Werte der oben geänderten öffentlichen Attribute:
Person p = (Person)obj;
//获取公有字段并调用，并修改
Field f = per.getField("Sex");
//获取一个对象：
Object obj = per.getConstructor().newInstance();
f.set(obj,"男"); //将Sex的属性修改成了 男
//调用私有的属性，并修改
f = per.getDeclaredField("name");
//在访问私有的属性的值之前，先要设置运行访问↓
//在访问之前忽略访问权限的检查，叫暴力反射
f.setAccessible(true);
f.set(obj,"张三");
System.out.println("Person里面的信息是："+p.toString());
}
}Ausgabe:
Erhalten Sie die Klasse durch Reflexionsmethoden (öffentlich, privat, Konstruktor). ):
Person-Klasse:
public class Person {
private String name; //名字
private int age = 18; //年龄
public int ID = 123; //身份证
public String Sex ; //性别
//构造：
public Person() {}
public Person(String name, int age, int ID, String sex) {
this.name = name;
this.age = age;
this.ID = ID;
Sex = sex;
}
//无参公有方法：
public void eat(){
System.out.println("我会吃饭");
}
//有参公有方法：
public void eat(String food){
System.out.println("我在吃："+food);
}
//有参私有方法
private void play(String name){
System.out.println(name+"在玩");
}
}Testklasse:
public class Test {
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
//获取到Person以及父类Object里面的public方法：
System.out.println("-----获取到Person以及父类Object里面的public方法↓-----");
for (Method method : Person.class.getMethods()) {
System.out.println(method);
System.out.println("方法名:"+ method.getName());
}
//获取到Person里面的方法，包括私有
System.out.println("-----获取到Person里面的方法，包括私有↓-----");
for (Method method:Person.class.getDeclaredMethods()) {
System.out.println(method.getName()+" ");
}
//按照方法名获取到Person中的eat方法：
System.out.println("-----根据方法名获取到Person类中的eat方法↓-----");
Method earMethod1 = Person.class.getMethod("eat");
Person per = new Person();
//通过invoke(Object,param...)来调用指定的方法
earMethod1.invoke(per);
//使用反射调用有参方法;
System.out.println("-----使用反射调用有参方法（传入参数）↓-----");
Method earMethod2 = Person.class.getMethod("eat",String.class);
earMethod2.invoke(per,"牛肉");
//通过暴力反射获取到私有的play方法:
System.out.println("-----通过暴力反射获取到私有的play方法传入参数）↓-----");
Method earMethod3 = Person.class.getDeclaredMethod("play", String.class);
//在访问私有的属性的方法之前，先要设置运行访问
earMethod3.setAccessible(true);
earMethod3.invoke(per,"小王");
}Ausgabe:
-----Holen Sie sich die öffentlichen Methoden in Person und übergeordneter Klasse Object↓--- --
public void Test02.Person.eat (java.lang.String)
Methodenname: eat
public void Test02.Person.eat()
Methodenname: eat
public final void java.lang.Object.wait() löst java.lang.InterruptedException aus
Methodenname: wait
public final void java.lang.Object.wait(long,int) löst java.lang.InterruptedException aus
Methodenname: wait
public final native void java.lang.Object.wait (long) löst java.lang.InterruptedException aus
Methodenname: wait
public boolean java.lang.Object.equals(java.lang.Object)
Methodenname: equal
public java.lang.String java.lang.Object.toString ()
Methodenname: toString
public native int java.lang.Object.hashCode()
Methodenname: hashCode
public final native java.lang.Class java.lang.Object.getClass()
Methodenname: getClass
public final native void java.lang.Object.notify ()
Methodenname: notify
public final native void java.lang.Object.notifyAll()
Methodenname: notifyAll
Das obige ist der detaillierte Inhalt vonBeispielanalyse des Java-Reflexionsmechanismusprinzips. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
