Article Préférer les interfaces à la réflexion

Réflexion en Java (java.lang.reflect) :
Par la réflexion, c'est possible :

• Accédez par programme aux constructeurs, aux méthodes et aux champs de classes arbitraires.
• Manipulez les classes et leurs membres (constructeurs, méthodes, champs) de manière réfléchie, vous permettant de créer des instances, d'invoquer des méthodes et d'accéder aux champs.
• Invoquez des méthodes sur les objets même si les classes n'existent pas lors de la compilation.

Inconvénients de la réflexion :
Perte de la vérification du type au moment de la compilation :

• Les erreurs qui seraient normalement détectées lors de la compilation n'apparaîtront qu'au moment de l'exécution.
• Exemple : L'appel réflexif d'une méthode inexistante ou inaccessible peut générer des exceptions au moment de l'exécution.

Code lourd et verbeux :
La réflexion nécessite un code plus complexe et moins lisible.
Exemple :

Method method = obj.getClass().getMethod("methodName");
method.invoke(obj, args);

Sous-performance :

• L'invocation de méthode réflexive est considérablement plus lente que l'invocation normale.
• Exemple : dans certains scénarios, la réflexion peut être jusqu'à 11 fois plus lente que l'invocation directe d'une méthode.

Applications de la réflexion :

• Utilisé dans les outils d'analyse de code, les frameworks d'injection de dépendances et les frameworks de fournisseurs de services.
• Même dans ces contextes, il doit être évité lorsque cela est possible en raison de ses inconvénients.

Utilisation limitée de la réflexion :
Technique suggérée : utilisez la réflexion uniquement pour instancier des classes inconnues au moment de la compilation et référencez ces instances via des interfaces ou des superclasses connues.

Exemple :
Programme qui crée des instances de Set, spécifiées par la ligne de commande :

Class<? extends Set<String>> cl = (Class<? extends Set<String>>) Class.forName(args[0]);
Constructor<? extends Set<String>> cons = cl.getDeclaredConstructor();
Set<String> s = cons.newInstance();
for (int i = 1; i < args.length; i++) {
    s.add(args[i]);
}
System.out.println(s);

Inconvénients illustrés dans l'exemple :
Exceptions d'exécution :

• L'exemple peut générer jusqu'à six exceptions différentes au moment de l'exécution.
• Ces exceptions seraient interceptées au moment de la compilation si la réflexion n'était pas utilisée.

Complexité et verbosité :

• L'exemple nécessite 25 lignes de code pour instancier une classe à partir de son nom, alors qu'un appel direct au constructeur se ferait sur une seule ligne.

Avertissement de diffusion non vérifié :

• Dans l'exemple, il y a un avertissement légitime de conversion non vérifiée, car la classe spécifiée sur la ligne de commande peut ne pas être une implémentation de Set.

Utilisation légitime de la réflexion :

• Dépendances dynamiques : lorsqu'une classe, une méthode ou un champ peut ne pas exister au moment de l'exécution.
• Exemple : vous pouvez utiliser la réflexion pour prendre en charge plusieurs versions d'un package sans rompre la compatibilité ascendante.

Conclusion :
La réflexion est puissante, mais elle présente de nombreux inconvénients.
Dans la mesure du possible, utilisez la réflexion uniquement pour instancier des objets et y accéder via des interfaces ou des superclasses connues au moment de la compilation.

Exemple tiré du livre :

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!