Quelle réflexion est Java ?

Qu'est-ce que la réflexion Java ?

La réflexion est l'une des fonctionnalités de Java et est un mécanisme permettant d'exploiter indirectement des objets cibles.

Le mécanisme de réflexion JAVA est en cours d'exécution. Pour n'importe quelle classe d'entité, vous pouvez connaître toutes les propriétés et méthodes de cette classe, pour n'importe quel objet, vous pouvez appeler n'importe laquelle de ses méthodes et propriétés ; dynamique La fonction d'obtention d'informations et d'appel dynamique de méthodes objet est appelée mécanisme de réflexion du langage Java.

Pourquoi la réflexion est-elle nécessaire en Java ? Quel problème la réflexion résout-elle ?

En une phrase, la réflexion peut être utilisée pour donner à jvm la possibilité de compiler dynamiquement, sinon les informations de métadonnées de la classe ne peuvent être obtenues que par compilation statique, comme. le chargement à chaud, le Classloader de Tomcat, etc. ne peuvent pas prendre en charge

Il existe deux types de compilation en Java :

● Compilation statique : le type est déterminé au moment de la compilation et l'objet lié est passé.

● Compilation dynamique : déterminez le type et liez l'objet au moment de l'exécution. La compilation dynamique maximise la flexibilité de Java, incarne des applications polymorphes et peut réduire le couplage entre les classes.

La réflexion Java est une propriété clé de Java étant considéré comme un langage dynamique (ou quasi-dynamique). Ce mécanisme permet au programme d'obtenir les informations internes de n'importe quelle classe avec un nom connu via les API Reflection au moment de l'exécution, y compris ses modificateurs (tels que public, static, etc.), sa superclasse (telle que Object), ses interfaces implémentées (telles que Cloneable) et Toutes les informations sur les champs et les méthodes, et peut modifier le contenu des champs ou appeler des méthodes au moment de l'exécution.

Reflection peut charger, détecter et utiliser des classes complètement inconnues lors de la compilation au moment de l'exécution. Autrement dit, un programme Java peut charger une classe dont le nom n'est connu qu'au moment de l'exécution, obtenir sa structure complète et générer son entité objet, ou définir des valeurs pour ses champs, ou appeler ses méthodes.

Reflection permet aux langages statiques d'inspecter et de modifier la structure et le comportement du programme au moment de l'exécution.
Dans les langages statiques, lorsque vous utilisez une variable, vous devez connaître son type. En Java, les informations de type des variables sont enregistrées dans le fichier de classe lors de la compilation, afin qu'elles puissent être précises au moment de l'exécution. En d'autres termes, le comportement du programme au moment de l'exécution est fixe. Si vous souhaitez le modifier au moment de l'exécution, vous avez besoin d'une réflexion.

Les classes qui implémentent le mécanisme de réflexion Java sont toutes situées dans le package java.lang.reflect :

1 Classe Class : représente une classe

2. : représente les variables membres de la classe (attributs de la classe)

3. Classe méthode : représente la méthode de la classe

4. Classe constructeur : représente la méthode de construction de la classe

.

5. Classe Array : permet de créer dynamiquement un tableau et d'accéder aux méthodes statiques des éléments du tableau

utilisez

1. Trois façons d'obtenir des objets de classe

1.1 Objet ——> getClass();
1.2 Toutes les données type (y compris les types de données de base) Il existe un attribut de classe "statique"
1.3 Via la méthode statique de la classe Class : forName (String className) (couramment utilisé)

/**
 * 获取Class对象的三种方式
 * 1 Object ——> getClass();
 * 2 任何数据类型（包括基本数据类型）都有一个“静态”的class属性
 * 3 通过Class类的静态方法：forName（String  className）(常用)
 *
 */
public class Fanshe {
	public static void main(String[] args) {
		//第一种方式获取Class对象  
		Student stu1 = new Student();//这一new 产生一个Student对象，一个Class对象。
		Class stuClass = stu1.getClass();//获取Class对象
		System.out.println(stuClass.getName());
		
		//第二种方式获取Class对象
		Class stuClass2 = Student.class;
		System.out.println(stuClass == stuClass2);
//判断第一种方式获取的Class对象和第二种方式获取的是否是同一个
		
		//第三种方式获取Class对象
		try {
			Class stuClass3 = Class.forName("fanshe.Student");
//注意此字符串必须是真实路径，就是带包名的类路径，包名.类名
			System.out.println(stuClass3 == stuClass2);
//判断三种方式是否获取的是同一个Class对象
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
 
		System.out.println("*****************获取公有、无参的构造方法*************");
		Constructor con = clazz.getConstructor(null);
		//1>、因为是无参的构造方法所以类型是一个null,不写也可以：这里需要的是一个参数的类型，切记是类型
		//2>、返回的是描述这个无参构造函数的类对象。
 
 
		System.out.println("*************获取公有字段**并调用*****************");
		Field f = stuClass.getField("name");
        System.out.println(f);
		
 
		System.out.println("***************获取私有的show4()方法******************");
		m = stuClass.getDeclaredMethod("show4", int.class);
		System.out.println(m);
		m.setAccessible(true);//解除私有限定
		Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（获取有反射），一个是实参
		System.out.println("返回值：" + result);
 
	}
}

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!