Introduction détaillée au mécanisme de réflexion Java

Cet article de la rubrique Introduction à la programmation Java présente en détail le mécanisme de réflexion en Java, dans l'espoir d'aider les étudiants qui ne comprennent pas ce mécanisme. Le mécanisme de

réflexion Java

est en cours d'exécution Pour n'importe quelle classe, il peut connaître toutes les propriétés et méthodes de cette classe (y compris les privées) ; object , peut appeler n'importe laquelle de ses méthodes et propriétés ; cette fonction d'obtention dynamique d'informations et d'appel dynamique de méthodes objet est appelée mécanisme de réflexion de Java.

Objectif :

Déterminer la classe à laquelle appartient tout objet au moment de l'exécution.

Construisez un objet de n'importe quelle classe au moment de l'exécution.

Jugez les variables membres et les méthodes de n'importe quelle classe au moment de l'exécution.

Appelez la méthode de n’importe quel objet au moment de l’exécution.

Générer un proxy dynamique.

Classes liées à la réflexion

classe de classe

obtenues dans le programme Java Objets de classe ont généralement les trois méthodes suivantes :

1. Utilisez la méthode statique forName (String clazzName) de la classe Class. Cette méthode nécessite de transmettre un paramètre chaîne dont la valeur est le nom complet d'une classe (le nom complet du package doit être ajouté).

2. Appelez l'attribut de classe d'une certaine classe pour obtenir l'objet Class correspondant à la classe.

3. Appelez la méthode getClass() d'un objet. Cette méthode est une méthode de la classe java.lang.Object.

Champ

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

Méthode

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对象对应类的、
带指定形参列表的方法

Constructeur

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

Générer des objets d'instance par réflexion

1 Utilisez la méthode newInstance() de l'objet Class pour créer une instance de la classe correspondante de l'objet Class. Cette méthode nécessite que la classe correspondante de l'objet Class ait un constructeur par défaut, et lorsque la méthode newInstance() est exécutée, le constructeur par défaut est en fait utilisé pour créer une instance de la classe.

2. Utilisez d'abord l'objet Class pour obtenir l'objet Constructor spécifié, puis appelez la méthode newInstance() de l'objet Constructor pour créer une instance de la classe correspondante de l'objet Class. De cette façon, vous pouvez choisir d'utiliser un constructeur spécifié pour créer l'instance.

Appeler la méthode

1. Obtenez la méthode spécifiée via la méthode getMethods() ou la méthode getMethod() de l'objet Class et renvoyez le tableau ou l'objet Method.

2. Appelez la méthode Object Invoke(Object obj, Object… args) dans l'objet Method. Le premier paramètre correspond à l'objet instance appelant la méthode, et le deuxième paramètre correspond aux paramètres de la méthode.

Exemple de code :

Qu'est-ce que la réflexion ?

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){
	}
}

Autres recommandations de vidéos d'apprentissage connexes : tutoriel vidéo Java

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!