Detaillierte Einführung in den Java-Reflexionsmechanismus

Dieser Artikel aus der Kolumne Einführung in die Java-Programmierung stellt den Reflexionsmechanismus in Java ausführlich vor und hofft, Schülern zu helfen, die diesen Mechanismus nicht verstehen.

Java Reflection

Der Mechanismus befindet sich im laufenden Zustand. Für jede Klasse kann er alle Eigenschaften und Methoden dieser Klasse kennen (einschließlich privater). Objekt kann jede seiner Methoden und Eigenschaften aufrufen. Diese Funktion zum dynamischen Abrufen von Informationen und zum dynamischen Aufrufen von Objektmethoden wird als Java-Reflexionsmechanismus bezeichnet.

Zweck:

Bestimmen Sie die Klasse, zu der ein Objekt zur Laufzeit gehört.

Konstruieren Sie zur Laufzeit ein Objekt einer beliebigen Klasse.

Beurteilen Sie die Mitgliedsvariablen und Methoden jeder Klasse zur Laufzeit.

Rufen Sie die Methode eines beliebigen Objekts zur Laufzeit auf.

Dynamischen Proxy generieren.

Reflexionsbezogene Klassen

Klassenklasse

in Java-Programmen erhaltene Klassenobjekte Normalerweise gibt es die folgenden drei Methoden:

1. Verwenden Sie die statische Methode forName (String clazzName) der Class-Klasse. Diese Methode erfordert die Übergabe eines String-Parameters, dessen Wert der vollständig qualifizierte Name einer Klasse ist (der vollständige Paketname muss hinzugefügt werden).

2. Rufen Sie das Klassenattribut einer bestimmten Klasse auf, um das der Klasse entsprechende Klassenobjekt zu erhalten.

3. Rufen Sie die getClass()-Methode eines Objekts auf. Diese Methode ist eine Methode in der Klasse java.lang.Object.

Feld

Field[] allFields = class2.getDeclaredFields();//获取class对象的所有属性
Field[] publicFields = class2.getFields();//获取class对象的public属性
Field ageField = class2.getDeclaredField("age");//获取class指定属性,可以获得私有属性
Field desField = class2.getField("des");//获取class指定的public属性

Methode

Method[] methods = class2.getDeclaredMethods();//获取class对象的所有声明方法
Method[] allMethods = class2.getMethods();//获取class对象的所有public方法 包括父类的方法
Method method = class2.getMethod("info", String.class);//返回次Class对象对应类的、带指定形参列表的public方法
Method declaredMethod = class2.getDeclaredMethod("info", String.class);//返回次Class对象对应类的、
带指定形参列表的方法

Konstruktor

Constructor<?>[] allConstructors = class2.getDeclaredConstructors();//获取class对象的所有声明构造函数
Constructor<?>[] publicConstructors = class2.getConstructors();//获取class对象public构造函数
Constructor<?> constructor = class2.getDeclaredConstructor(String.class);//获取指定声明构造函数
Constructor publicConstructor = class2.getConstructor(String.class);//获取指定声明的public构造函数

Instanzobjekte durch Reflektion generieren

1. Verwenden Sie die newInstance()-Methode des Class-Objekts, um eine Instanz der entsprechenden Klasse des Class-Objekts zu erstellen. Diese Methode erfordert, dass die entsprechende Klasse des Klassenobjekts über einen Standardkonstruktor verfügt. Wenn die Methode newInstance () ausgeführt wird, wird der Standardkonstruktor tatsächlich zum Erstellen einer Instanz der Klasse verwendet.

2. Verwenden Sie zuerst das Class-Objekt, um das angegebene Constructor-Objekt abzurufen, und rufen Sie dann die newInstance()-Methode des Constructor-Objekts auf, um eine Instanz der entsprechenden Klasse des Class-Objekts zu erstellen. Auf diese Weise können Sie einen bestimmten Konstruktor zum Erstellen der Instanz verwenden.

Methode aufrufen

1. Rufen Sie die angegebene Methode über die Methode getMethods() oder die Methode getMethod() des Klassenobjekts ab und geben Sie das Methodenarray oder -objekt zurück.

2. Rufen Sie die Methode Object invoke(Object obj, Object… args) im Methodenobjekt auf. Der erste Parameter entspricht dem Instanzobjekt, das die Methode aufruft, und der zweite Parameter entspricht den Parametern der Methode.

Beispielcode:

Was ist Reflexion?

package am;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
import javax.activation.FileDataSource;
/**
 * 反射是什么：
 *    java中的反射：就是在类的加载过程中，发现类的属性和方法构造方法等信息。可以获得类的属性值，可以调用类的方法。
 *    
 * 
 * 反射获得类的对象。
 *
 */
public class Demo01 {
	public static void main(String[] args) throws Exception{
		// 通过反射，获取类的对象。
		Object obj = create("am.Foo");;
		Foo foo = (Foo)obj;
		System.out.println(foo.a);
		double dou = foo.show(12, "hello");
		System.out.println(dou);
		System.out.println("======================================");
		// 获得类的属性
		showField(obj);
		System.out.println("======================================");
		double a = (double)getFieldValue(obj, "b");
		System.out.println(a);
		System.out.println("========================================");
		// 通过反射调用方法。
		Object ob = getMethodValue(obj,"show",new Class[]{int.class,String.class},new Object[]{23,"abc"});
		double douValue = (double)ob;
		System.out.println(douValue);
	}
//通过反射调用方法，哪个对象，什么名称，参数类型，参数值
	public static Object getMethodValue(Object obj,String method,Class[] paramType,Object[] param)
	throws Exception{
		Class cla = obj.getClass();
		Method me = cla.getDeclaredMethod(method, paramType);
		Object o = me.invoke(obj, param);
		return o;
	}
	// 获取类的属性值:
	public static Object getFieldValue(Object obj,String name)throws Exception{
		Class cla = obj.getClass();// 获取字节码对象。
		Field field = cla.getDeclaredField(name);// 通过属性的名称。获取当前属性。
		Object result = field.get(obj);
		return result;
	}
	// 通过反射，可以获得类的属性信息以及方法信息。
	public static void showField(Object obj){
		// java中对属性类。 Field   方法类：Method
		Class cla = obj.getClass();
		System.out.println("获取类名："+cla.getName());
		System.out.println("======================================");
		// 获取类的属性：
		Field[] fields = cla.getDeclaredFields();// 获取公开的属性。
		for(Field field : fields){
			System.out.println("获取类的属性类型"+field.getType());
			System.out.println("获取类的属性名称："+field.getName());
		}
		System.out.println("======================================");
		// 获取类的方法。
		Method[] methods = cla.getDeclaredMethods();
		for(Method method : methods){
			System.out.println("获取方法的返回值类型："+method.getReturnType());
			System.out.println("获取方法名称："+method.getName());
			System.out.println("获取方法的参数类型。"+Arrays.toString(method.getParameterTypes()));
		}
		System.out.println("=======================================");
		// 获取类的构造方法：
		Constructor[] cons = cla.getDeclaredConstructors();
		for(Constructor con : cons){
			System.out.println("构造方法的名字："+con.getName());
			System.out.println("构造方法参数类型："+Arrays.toString(con.getParameterTypes()));
		}	
	}
	// 如何反射类的实例。
	public static Object create(String name) throws Exception{
		// 反射的方法。Class.forName();
		Class cla = Class.forName(name);
		// 如何获得Object类型对象。
		Object obj = cla.newInstance();
		return obj;
	}
}
// 模拟类。
class Foo{
	int a = 10;
	double b = 20;
	public double show(int p,String str){
		System.out.println("调用方法传入的值是："+str);
		return a+b+p;
	}
	public Foo(){
	}
	public Foo(int a,int b){
	}
}

Weitere verwandte Lernvideoempfehlungen: Java-Video-Tutorial

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in den Java-Reflexionsmechanismus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!