Qu'est-ce que la réflexion et pourquoi est-il utile?

Ce qui est de la réflexion, et pourquoi est-il utile?

Je m'intéresse plus particulièrement à Java, mais je suppose que les principes sont les mêmes dans toutes les langues.

Pour moi, c'est un moyen d'obtenir les noms de classe au moment de l'exécution et de la création d'objets de cette classe.
parce que c'est une question populaire, je tiens à souligner que la réflexion (Sans annotations) doit être le dernier outil que vous aller lors de la résolution d'un problème. - Je l'utiliser et de l'amour, mais il annule tous les avantages de Java du typage statique. Si vous avez besoin d', l'isoler à un secteur aussi restreint que possible (d'Une méthode ou d'une classe). Il est plus acceptable pour les utiliser dans des tests de code de production. Avec des annotations elle doit être fine-Le point principal est de ne pas spécifier la classe ou la méthode des noms comme "Strings" si on peut l'éviter.
voir aussi: softwareengineering.stackexchange.com/questions/123956/...
En plus de @BillK commentaire: la Réflexion est très puissant, je l'appellerais de la magie. Avec un grand pouvoir vient une grande responsabilité. Utilisez-le seulement si vous savez ce que vous faites.
Vous pouvez éviter de nombreux écueils impliqués dans la réflexion à l'aide de Collecteur @Jailbreak. Il fournit directement, type-safe accéder aux champs privés, des méthodes, etc. Laisser le compilateur Java en toute sécurité vérifier votre code et laissez Collecteur générer les sous-tendent la réflexion d'accès pour vous. En savoir plus: collecteur.systèmes/docs.html#type-safe-reflet

InformationsquelleAutor Lehane | 2008-09-01

1634

Le nom de la réflexion est utilisé pour décrire le code qui est en mesure d'inspecter un autre code dans le même système (ou lui-même).

Par exemple, disons que vous avez un objet de type inconnu en Java, et vous souhaitez appeler un "doSomething' méthode si celle-ci existe. Java statique du système de typage n'est pas vraiment conçu pour l'appui de cette à moins que l'objet est conforme à une interface connue, mais l'utilisation de la réflexion, votre code peut ressembler à l'objet et savoir si il a une méthode appelée "doSomething' et ensuite l'appeler si vous le souhaitez.

Donc, pour vous donner un exemple de code de ce en Java (imaginez l'objet en question est toto) :
```
Method method = foo.getClass().getMethod("doSomething", null);
method.invoke(foo, null);
```
Un usage très courant en cas de Java est l'utilisation avec des annotations. JUnit 4, par exemple, utiliser la réflexion pour regarder à travers vos classes pour les méthodes taggés avec l'annotation @Test, et ensuite les appeler lors de l'exécution de l'unité de test.

Il y a quelques bons réflexion exemples pour vous obtenir ont commencé à http://docs.oracle.com/javase/tutorial/reflect/index.html

Et enfin, oui, les concepts sont à peu près similaires dans d'autres statique des types de langues, qui soutien à la réflexion (comme le C#). Dans typées dynamiquement langues, le cas d'utilisation décrit ci-dessus est moins nécessaire (puisque le compilateur va permettre à toute méthode doit être appelée à n'importe quel objet, à défaut lors de l'exécution si elle n'existe pas), mais le deuxième cas de la recherche de méthodes qui sont marqués ou de travailler dans une certaine manière, elle est encore fréquente.

Mise à jour à partir d'un commentaire:

La capacité d'inspecter le code dans le système et de voir les types d'objet est
pas de réflexion, mais plutôt le Type de l'Introspection. La réflexion est alors l'
capacité d'apporter des modifications au moment de l'exécution, par l'emploi de
l'introspection. La distinction est nécessaire ici que certaines langues
soutien à l'introspection, mais ne prennent pas en charge la réflexion. Un exemple
est le C++
- peut-u s'il vous plaît expliquer ce qu'est la signification de ce paramètre null dans cette ligne de la Méthode method = foo.getClass().getMethod("doSomething", null);
- L'null indique qu'il n'existe pas de paramètres passés à la méthode foo. Voir docs.oracle.com/javase/6/docs/api/java/lang/reflect/..., java.lang.Objet...) pour plus de détails.
- Juste pour dissiper puisque cela a donc beaucoup de upvotes. La capacité d'inspecter le code dans le système et de voir les types d'objet n'est pas la réflexion, mais plutôt le Type de l'Introspection. La réflexion est alors la capacité d'apporter des modifications au moment de l'exécution, en faisant usage de l'introspection. La distinction est nécessaire ici que certaines langues de soutien à l'introspection, mais ne prennent pas en charge la réflexion. Un tel exemple est le C++.
- J'aime la réflexion, mais si vous avez le contrôle sur le code, puis à l'aide de la réflexion, comme indiqué dans cette réponse est unnessary et donc un abus--Vous devez utiliser le Type de l'Introspection (instanceof) et fortes. Si il n'y a aucune façon, mais la réflexion pour faire quelque chose, c'est comment il devrait être fait. La réflexion provoque de graves chagrin d'amour parce que vous perdez tous les avantages de l'utilisation d'un langage statiquement typé. Si vous en avez besoin vous en avez besoin, cependant, même alors, je voudrais examiner un pré-emballés solution, comme le Printemps ou quelque chose de complètement encapsule la réflexion nécessaire--c'est à dire: laisser quelqu'un d'autre a des maux de tête.
- N'est-ce pas l'introspection de même que l'auto-réflexion?
- Je viens de réaliser une chose c'est peut-être ce que je suis en train de faire en JavaScript? J'ouvre firebugs/chrome inspecteur de brancher un point de rupture et de voir ce que mon code fait sur ce point, également à la recherche de méthodes si elle existe sur une instance et de l'essayer et de vérifier ce qu'il crache? Tout ceci fait de l'exécution. Si c'est le cas de wow, c'est ce qu'il est.
- Où avez-vous cette information? Je vois le terme "réflexion" officielles utilisées dans la documentation Java d'Oracle pour décrire non seulement la capacité de faire des changements au moment de l'exécution, mais aussi la capacité de voir le type d'un objet. Ne pas oublier que la plupart des soi-disant "type introspection" classes associées (ex: Method, Constructor, Modifier, Field, Member, fondamentalement, apparemment tous sauf Class) sont à l'intérieur de la java.lang.*reflect* paquet. Peut-être le concept de "réflexion" de manière exhaustive, comprend à la fois de type "introspection" et de modification au moment de l'exécution?
- c'est une bonne hypothèse. La réflexion s'appuie sur l'introspection et donc comprend que comme une pièce. Mon commentaire était pour préciser que la réflexion permet d'exécution des modifications. La réponse donne un exemple qui montre que ces runtime modifications intervenues, mais définit la réflexion que juste la capacité de faire de l'introspection. Cette question a une très haute SEO pour la réflexion et j'ai pensé qu'il était important d'ajouter des précisions supplémentaires.
- C++ n'est pas, à ce moment, le type de support introspection, de toute façon. Il est prévu pour une future version. Certains outils externes (tels que Qt moc) extension de C++ avec le type de capacités d'introspection.
- C# et dynamique des objets et des objets anonymes, comme ExpandoObject
- Il est inutile pour les non les éditeurs Java. Il serait fou si vous pouviez modifier les classes d'attributs ou méthodes au moment de l'exécution.
- qui n'est pas exacte, au moins dans le monde Java. La réflexion est l'API pour à la fois obtenir et de définir cette information au moment de l'exécution alors que l'introspection est le processus de l'inspection des java beans, basé sur la méthode de la convention de nommage et de réflexion stackoverflow.com/questions/2044446/...
InformationsquelleAutor Matt Sheppard
228

Réflexion est une langue de la capacité d'inspecter et d'appeler de manière dynamique les classes, méthodes, attributs, etc. au moment de l'exécution.

Par exemple, tous les objets en Java ont la méthode getClass(), qui permet de déterminer la classe de l'objet, même si vous ne savez pas au moment de la compilation (par exemple, si vous avez déclaré comme un Object) - cela peut sembler trivial, mais cette réflexion n'est pas possible à moins de langages dynamiques tels que C++. Plus avancé utilise vous permet de liste et appeler des méthodes, constructeurs, etc.

Réflexion est importante, car elle permet d'écrire des programmes qui n'ont pas de "savoir" tout ce au moment de la compilation, les rendant plus dynamique, car ils peuvent être attachés ensemble au moment de l'exécution. Le code peut être écrit contre connu des interfaces, mais les classes à utiliser peut être instancié en utilisant la réflexion à partir de fichiers de configuration.

Beaucoup de modernes des cadres d'utiliser la réflexion largement pour cette raison. La plupart des autres langues modernes utiliser la réflexion, et les langages de script (comme Python), ils sont encore plus étroitement intégré, car il se sent plus naturel dans le modèle de programmation de ces langues.
- Donc, en d'autres termes, vous pouvez créer une instance du nom qualifié et le compilateur ne pas se plaindre à ce sujet (parce que dire que vous utilisez seulement une Chaîne de caractères pour le nom de la classe). Puis, au moment de l'exécution, si cette classe n'est pas présent, vous obtenez une exception. Vous sorte de contourné le compilateur dans ce cas. Voulez-vous me donner quelques cas d'utilisation spécifiques pour cela? Je ne peux pas l'image quand je le choisir.
- s'il est vrai qu'il est facile de créer des erreurs d'exécution, à la réflexion, il est aussi parfaitement possible d'utiliser la réflexion, sans risquer des exceptions d'exécution. Comme évoqué dans ma réponse, un usage commun de la réflexion est pour les bibliothèques ou les cadres, qui sont explicitement vous ne pouvez pas connaître la structure de la demande au moment de la compilation, car ils sont compilés séparé de l'application. Toute bibliothèque qui utilise le code "par convention" est susceptible d'utiliser la réflexion, mais pas nécessairement à l'aide de la magie des cordes.
InformationsquelleAutor Liedman

104

L'un de mes préférés utilise de réflexion est en dessous de Java méthode de vidage. Il prend l'objet en tant que paramètre et utilise la réflexion Java API pour imprimer chaque nom de champ et la valeur.

import java.lang.reflect.Array;
import java.lang.reflect.Field;
public static String dump(Object o, int callCount) {
callCount++;
StringBuffer tabs = new StringBuffer();
for (int k = 0; k < callCount; k++) {
tabs.append("\t");
}
StringBuffer buffer = new StringBuffer();
Class oClass = o.getClass();
if (oClass.isArray()) {
buffer.append("\n");
buffer.append(tabs.toString());
buffer.append("[");
for (int i = 0; i < Array.getLength(o); i++) {
if (i < 0)
buffer.append(",");
Object value = Array.get(o, i);
if (value.getClass().isPrimitive() ||
value.getClass() == java.lang.Long.class ||
value.getClass() == java.lang.String.class ||
value.getClass() == java.lang.Integer.class ||
value.getClass() == java.lang.Boolean.class
) {
buffer.append(value);
} else {
buffer.append(dump(value, callCount));
}
}
buffer.append(tabs.toString());
buffer.append("]\n");
} else {
buffer.append("\n");
buffer.append(tabs.toString());
buffer.append("{\n");
while (oClass != null) {
Field[] fields = oClass.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
buffer.append(tabs.toString());
fields[i].setAccessible(true);
buffer.append(fields[i].getName());
buffer.append("=");
try {
Object value = fields[i].get(o);
if (value != null) {
if (value.getClass().isPrimitive() ||
value.getClass() == java.lang.Long.class ||
value.getClass() == java.lang.String.class ||
value.getClass() == java.lang.Integer.class ||
value.getClass() == java.lang.Boolean.class
) {
buffer.append(value);
} else {
buffer.append(dump(value, callCount));
}
}
} catch (IllegalAccessException e) {
buffer.append(e.getMessage());
}
buffer.append("\n");
}
oClass = oClass.getSuperclass();
}
buffer.append(tabs.toString());
buffer.append("}\n");
}
return buffer.toString();
}

Ce qui devrait Callcount être réglé sur?
J'ai eu une Exception in thread "AWT-EventQueue-0" java.lang.StackOverflowError quand j'ai couru ce.
doit être mis à zéro. Sa valeur est utilisée pour déterminer combien d'onglets devraient précéder chaque ligne de la sortie: à chaque fois dump besoin d'un dump d'un "sous-objet", la sortie serait d'imprimer imbriquée dans le parent. Cette méthode s'avère utile lorsque enveloppé dans une autre. Envisager printDump(Object obj){ System.out.println(dump(obj, 0)); }.
La java.lang.StackOverflowError pourraient être créés en cas de références circulaires, en raison de la décoché la récursivité: la mémoire tampon.append(dump(valeur, callCount))
Vous libérer de votre code dans le Domaine Public, jolie s'il vous plaît?

InformationsquelleAutor Ben Williams

77

Utilise de Réflexion

Réflexion est couramment utilisé par les programmes qui exige la capacité d'examiner ou de modifier le comportement d'exécution des applications en cours d'exécution dans la machine virtuelle Java. Ce qui est relativement fonctionnalité avancée et doit être utilisé uniquement par des développeurs qui ont une solide compréhension des principes de base de la langue. Avec cette mise en garde à l'esprit, la réflexion est une technique puissante qui permet des applications pour effectuer des opérations qui seraient autrement impossibles.

Fonctionnalités D'Extensibilité

Une application peut faire usage externe, classes définies par l'utilisateur en créant des instances de l'extensibilité des objets à l'aide de leurs noms qualifiés complets.
La classe des Navigateurs et des Environnements de Développement Visual
Un navigateur de classe doit être en mesure d'énumérer les membres de classes. Visual environnements de développement peuvent bénéficier de l'utilisation du type d'information disponible dans la réflexion pour aider le développeur dans l'écriture de code correct.
Les débogueurs et Outils de Test
Débogueurs besoin pour être en mesure d'examiner privée membres de les classes. Harnais de Test peuvent faire usage de la réflexion à demander systématiquement une découvrable ensemble Api définies sur une classe, afin d'assurer un niveau élevé de couverture de code dans une suite de tests.

Inconvénients de Réflexion

Réflexion est puissant, mais ne doit pas être utilisé sans discernement. Si il est possible d'effectuer une opération sans l'aide de la réflexion, il est préférable d'éviter de l'utiliser. Les aspects suivants doivent être gardés à l'esprit lors de l'accès à code par la réflexion.
- Des Performances
Parce que la réflexion implique des types qui sont dynamiquement résolu, certains de la machine virtuelle Java optimisations ne peut pas être effectuée. Par conséquent, réfléchissant opérations baisse des performances de leur non-réfléchissant homologues et doit être évitée dans les sections de code qui sont appelés fréquemment dans les performances des applications sensibles.
- Restrictions De Sécurité
Réflexion nécessite un temps d'exécution de l'autorisation qui ne peut être présent lors de l'exécution en vertu d'un gestionnaire de sécurité. Ceci est une considération importante pour le code qui doit s'exécuter dans une mesure limitée contexte de sécurité, comme dans une Applet.
- De l'exposition interne
Depuis la réflexion permet code pour effectuer des opérations qui seraient illégales au non-réfléchissant code, telles que l'accès aux champs privés et des méthodes, l'utilisation de la réflexion, peut entraîner des effets secondaires inattendus, ce qui peut rendre le code de dysfonctionnements et peut détruire la portabilité. Réfléchissant code des pauses abstractions et, par conséquent, peuvent changer de comportement avec les mises à niveau de la plate-forme.

source: L'API Reflection

InformationsquelleAutor Desmond Smith
40

Réflexion est un mécanisme clé pour permettre à une application ou d'un cadre de travail avec un code qui ne pourrait pas avoir été encore écrit!

Prendre pour exemple typique de votre web.xml fichier. Il contient une liste de servlet éléments, qui contiennent imbriquée servlet-class éléments. Le conteneur de servlet sera procédé à la web.xml fichier, et de créer une nouvelle instance de chaque classe de servlet par la réflexion.

Un autre exemple serait la Java API for XML Parsing (JAXP). Où un analyseur XML fournisseur est "branché" par la bien connue des propriétés du système, qui sont utilisés pour construire de nouvelles instances par le biais de la réflexion.

Et enfin, le plus complet exemple est Printemps qui utilise la réflexion pour créer ses grains, et pour sa forte utilisation de procurations

InformationsquelleAutor toolkit
35

Pas tous la langue prend en charge la réflexion, mais les principes sont généralement les mêmes dans les langues qui le prennent en charge.

La réflexion est la capacité à "réfléchir" sur la structure de votre programme. Ou plus concrète. Pour regarder les objets et les classes que vous avez et obtenir par programme de retour d'informations sur les méthodes, les champs, et les interfaces ils mettent en œuvre. Vous pouvez aussi regarder les choses comme les annotations.

Il est utile dans beaucoup de situations. Partout où vous voulez être en mesure de dynamiquement plug dans les classes dans votre code. Beaucoup de objet-relationnel mappeurs utiliser la réflexion pour être en mesure d'instancier des objets de bases de données sans savoir à l'avance quels sont les objets qu'ils vont utiliser. Plug-in architectures est un autre endroit où la réflexion est utile. Être en mesure de charger dynamiquement du code et de déterminer si il y a des types qui mettent en œuvre le droit de l'interface pour l'utiliser comme un plugin est important dans ces situations.
- J'ai besoin d'instancier des objets basés sur les données présentes dans la base de données. Je crois que c'est ce que vous dites à propos. Exemple de code qui serait m'aider beaucoup. Merci à l'avance.
InformationsquelleAutor Mendelt
33

Réflexion permet l'instanciation de nouveaux objets, l'invocation de méthodes, et obtenir/définir des opérations sur les variables de classe dynamiquement au moment de l'exécution, sans avoir une connaissance préalable de sa mise en œuvre.
```
Class myObjectClass = MyObject.class;
Method[] method = myObjectClass.getMethods();
//Here the method takes a string parameter if there is no param, put null.
Method method = aClass.getMethod("method_name", String.class); 
Object returnValue = method.invoke(null, "parameter-value1");
```
Dans l'exemple ci-dessus, le paramètre null est l'objet que vous voulez appeler la méthode sur. Si la méthode est statique, vous offre null. Si la méthode n'est pas statique, tout en invoquant vous devez fournir un valide MyObject exemple au lieu de null.

Réflexion vous permet également d'accéder membre privé/les méthodes d'une classe:
```
public class A{
private String str= null;
public A(String str) {
this.str= str;
}
}
```
.
```
A obj= new A("Some value");
Field privateStringField = A.class.getDeclaredField("privateString");
//Turn off access check for this field
privateStringField.setAccessible(true);
String fieldValue = (String) privateStringField.get(obj);
System.out.println("fieldValue = " + fieldValue);
```
- Pour l'inspection des classes (aussi connu comme l'introspection), vous n'avez pas besoin d'importer de la réflexion paquet (java.lang.reflect). Les métadonnées de la classe peuvent être accessibles par le biais de java.lang.Class.
La réflexion est un très puissant API, mais il peut ralentir l'application si utilisé en excès, qu'il n'en résout tous les types à l'exécution.

InformationsquelleAutor Nikhil Shekhar
21

Réflexion Java est très puissant et peut être très utile.
Java Réflexion permet pour inspecter les classes, les interfaces, les champs et les méthodes d'exécution, sans connaître les noms des classes, des méthodes, etc. au moment de la compilation.
Il est également possible de instancier de nouveaux objets, d'invoquer des méthodes et d'obtenir/définir des valeurs de champ à l'aide de la réflexion.

Une rapide Réflexion Java exemple pour vous montrer ce que l'utilisation de la réflexion ressemble:
```
Method[] methods = MyObject.class.getMethods();
for(Method method : methods){
System.out.println("method = " + method.getName());
}
```
Cet exemple obtient l'objet de Classe de la classe appelée MyObject. L'utilisation de la classe de l'objet de l'exemple permet d'obtenir une liste des méthodes de la classe, réitère les méthodes et imprimer leurs noms.

Exactement comment tout cela fonctionne est expliqué ici

Modifier: Après presque 1 an, je suis l'édition de cette réponse que lors de la lecture de la réflexion j'ai eu plusieurs utilisations de la Réflexion.
- Printemps utilise bean configuration, comme par exemple:
```
<bean id="someID" class="com.example.Foo">
<property name="someField" value="someValue" />
</bean>
```
Au Printemps lorsque le contexte des processus de ce < bean > élément, il va utiliser la Classe.forName(String) avec l'argument "com.exemple.Foo" pour instancier cette Classe.

Il sera alors de nouveau utiliser la réflexion pour obtenir les setter pour le < propriété > élément et définissez sa valeur à la valeur spécifiée.
- Junit utilise la Réflexion en particulier pour les tests Privé/Protégé méthodes.
Pour les méthodes Privées,
```
Method method = targetClass.getDeclaredMethod(methodName, argClasses);
method.setAccessible(true);
return method.invoke(targetObject, argObjects);
```
Pour les champs privés,
```
Field field = targetClass.getDeclaredField(fieldName);
field.setAccessible(true);
field.set(object, value);
```
InformationsquelleAutor VdeX
21

Exemple:

Prendre pour exemple une application à distance qui permet à votre application d'un objet que vous pouvez obtenir l'aide de leurs Méthodes de l'API . Désormais basées sur l'objet que vous pourriez avoir besoin pour effectuer un type de calcul .

Le fournisseur garantit que l'objet peut être de 3 types, et nous avons besoin d'effectuer le calcul en fonction du type d'objet .

De sorte que nous pourrions mettre en œuvre en 3 classes contenant chacune une logique différente .Évidemment, l'objet de l'information est disponible dans l'exécution afin que vous ne pouvez pas statique de code pour effectuer le calcul d'où la réflexion est utilisé pour instancier l'objet de la classe dont vous avez besoin pour effectuer le calcul en fonction de l'objet reçu de la part du fournisseur .
- J'ai besoin de quelque chose de similaire.. Un exemple m'aiderait beaucoup car je suis nouveau à la réflexion des concepts..
- Je suis confus: ne pouvez-vous pas utiliser instanceof pour déterminer le type de l'objet au moment de l'exécution?
InformationsquelleAutor human.js
17

Réflexion est une API qui est utilisé pour interroger ou de modifier le comportement de méthodes, classes, interfaces au moment de l'exécution.
1. Les classes nécessaires à la réflexion sont fournis en vertu de java.lang.reflect package.
2. Réflexion nous donne des informations sur la classe à laquelle appartient un objet et aussi les méthodes de la classe qui peut être exécutée à l'aide de l'objet.
3. Par la réflexion que nous pouvons appeler des méthodes lors de l'exécution, quel que soit le spécificateur d'accès utilisé avec eux.
La java.lang et java.lang.reflect paquets fournissent des classes java pour la réflexion.

Réflexion peut être utilisé pour obtenir des informations sur –
1. Classe La getClass() méthode est utilisée pour obtenir le nom de la classe à laquelle appartient un objet.
2. Constructeurs La getConstructors() méthode est utilisée pour obtenir le public, les constructeurs de la classe à laquelle appartient un objet.
3. Méthodes La getMethods() méthode est utilisée pour obtenir les méthodes publiques de la classe à laquelle un objet appartient.
La API Reflection est principalement utilisé dans:

IDE (Environnement de Développement Intégré), comme par exemple Eclipse, MyEclipse, NetBeans ...

Débogueur et Outils de Test etc.

Avantages de l'Utilisation de la Réflexion:

Fonctionnalités d'extensibilité: Une application peut faire usage externe, classes définies par l'utilisateur en créant des instances de l'extensibilité des objets à l'aide de leurs noms qualifiés complets.

De débogage et de test des outils: Débogueurs utiliser la propriété de réflexion pour examiner privée membres de les classes.

Inconvénients:

Surcharge de Performance: Réfléchissant opérations baisse des performances de leur non-réfléchissant homologues, et doit être évitée dans les sections de code qui sont appelés fréquemment dans les performances des applications sensibles.

De l'exposition interne: Réfléchissant code des pauses abstractions et, par conséquent, peuvent changer le comportement des mises à niveau de la plate-forme.

Ref: Réflexion Java javarevisited.blogspot.dans
- Je voudrais ajouter à la inconvénients "Il se casse refactoring". Pour moi, c'est la raison principale pour éviter la réflexion autant que possible.
- Elle nous permet (par exemple), pour inspecter les classes que nous avons (si nous avons des instances ou pas), c'est exact? Par cela, je veux dire, obtenir leurs méthodes ou les constructeurs et les utiliser pour créer de nouvelles instances/les invoquer. Pourquoi disons-nous "changer le comportement du programme" si le problème est déjà là, mais avec un code différent? Pourquoi est-il appelé "réflexion"? Merci
InformationsquelleAutor roottraveller

Exemple Simple pour la réflexion.
Dans un jeu d'échecs, vous ne savez pas ce qui va être déplacé par l'utilisateur au moment de l'exécution. la réflexion peut être utilisé pour appeler des méthodes qui sont déjà mises en œuvre au moment de l'exécution:

public class Test {
public void firstMoveChoice(){
System.out.println("First Move");
} 
public void secondMOveChoice(){
System.out.println("Second Move");
}
public void thirdMoveChoice(){
System.out.println("Third Move");
}
public static void main(String[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException { 
Test test = new Test();
Method[] method = test.getClass().getMethods();
//firstMoveChoice
method[0].invoke(test, null);
//secondMoveChoice
method[1].invoke(test, null);
//thirdMoveChoice
method[2].invoke(test, null);
}
}

InformationsquelleAutor Isuru Jayakantha

15

Selon ma compréhension:

Réflexion permet au programmeur de l'accès des entités dans le programme de façon dynamique. c'est à dire lors de l'encodage d'une demande si le programmeur n'est au courant à propos d'une classe ou de ses méthodes, il peut faire usage de cette classe de manière dynamique (à l'exécution) par l'aide de la réflexion.

Il est fréquemment utilisé dans les cas où un nom de classe à de fréquents changements. Si une telle situation se produit, alors c'est compliqué pour le programmeur de réécrire l'application et modifier le nom de la classe, encore et encore.

Au lieu de cela, par l'aide de la réflexion, il n'est besoin de s'inquiéter d'un éventuel changement de nom de la classe.

InformationsquelleAutor pramod
14

La réflexion est un ensemble de fonctions qui vous permet d'accéder aux informations d'exécution de votre programme et de le modifier le comportement (avec certaines limitations).

C'est utile parce qu'il permet de changer le moteur d'exécution behaivour selon les méta-informations de votre programme, vous pouvez vérifier le type de retour d'une fonction et de changer la façon dont vous gérer la situation.

En C# par exemple, vous pouvez charger un assembly (un .dll) lors de l'exécution d'un de l'examiner, de la navigation au travers de cours et de prendre des mesures en fonction de ce que vous avez trouvé. Il vous permet également de créer une instance d'une classe sur l'exécution, invoquer sa méthode, etc.

Où peut-elle être utile? N'est pas utile, à chaque fois, mais pour des situations concrètes. Par exemple, vous pouvez l'utiliser pour obtenir le nom de la classe pour loggin fins, à dinamically créer des gestionnaires d'événements pour les événements en fonction de ce qui est spécifié sur un fichier de configuration et ainsi de suite...

InformationsquelleAutor Jorge Córdoba
11

Réflexion est de laisser l'objet à voir leur apparence. Cet argument ne semble rien à voir avec la réflexion. En fait, c'est le "s'identifier" la capacité.

La réflexion elle-même est un mot pour les langues telles que le manque de la capacité de la connaissance de soi et l'auto-détection comme Java et C#. Parce qu'ils n'ont pas la capacité de connaissance de soi, lorsque l'on veut observer comment il ressemble, nous devons avoir une autre chose à réfléchir sur la façon dont il ressemble. Excellent langages dynamiques tels que Ruby et Python, il est possible de percevoir le reflet de leur propre sans l'aide d'autres personnes. Nous pouvons dire que l'objet de Java ne pas voir à quoi ça ressemble sans un miroir, qui est un objet de la réflexion de la classe, mais un objet en Python peut la percevoir sans miroir. C'est pourquoi nous avons besoin de réflexion en Java.
- type(), isinstance(), remboursables(), dir() et getattr(). .... ce sont pythonic réflexion appels
InformationsquelleAutor Marcus Thornton

Je veux juste ajouter un point à tout ce qui a été répertorié.

Avec API Reflection vous pouvez écrire universelle toString() méthode pour n'importe quel objet.

Il est utile pour le débogage.

Voici quelques exemple:

class ObjectAnalyzer {
private ArrayList<Object> visited = new ArrayList<Object>();
/**
* Converts an object to a string representation that lists all fields.
* @param obj an object
* @return a string with the object's class name and all field names and
* values
*/
public String toString(Object obj) {
if (obj == null) return "null";
if (visited.contains(obj)) return "...";
visited.add(obj);
Class cl = obj.getClass();
if (cl == String.class) return (String) obj;
if (cl.isArray()) {
String r = cl.getComponentType() + "[]{";
for (int i = 0; i < Array.getLength(obj); i++) {
if (i > 0) r += ",";
Object val = Array.get(obj, i);
if (cl.getComponentType().isPrimitive()) r += val;
else r += toString(val);
}
return r + "}";
}
String r = cl.getName();
//inspect the fields of this class and all superclasses
do {
r += "[";
Field[] fields = cl.getDeclaredFields();
AccessibleObject.setAccessible(fields, true);
//get the names and values of all fields
for (Field f : fields) {
if (!Modifier.isStatic(f.getModifiers())) {
if (!r.endsWith("[")) r += ",";
r += f.getName() + "=";
try {
Class t = f.getType();
Object val = f.get(obj);
if (t.isPrimitive()) r += val;
else r += toString(val);
} catch (Exception e) {
e.printStackTrace();
}
}
}
r += "]";
cl = cl.getSuperclass();
} while (cl != null);
return r;
}    
}

InformationsquelleAutor nazar_art

9

De documentation de java page

java.lang.reflect paquet fournit des classes et des interfaces pour l'obtention réfléchissant d'informations sur les classes et les objets. La réflexion permet l'accès par programme à l'information sur les champs, les méthodes et les constructeurs des classes chargées, et l'utilisation réfléchie des champs, des méthodes et des constructeurs pour fonctionner sur leurs homologues, dans les restrictions de sécurité.

AccessibleObject permet la suppression des contrôles d'accès si nécessaire ReflectPermission est disponible.

Les Classes de ce package, avec java.lang.Class accueillir des applications telles que des débogueurs, des interprètes, objet d'inspecteurs, de la classe des navigateurs, et des services tels que Object Serialization et JavaBeans qui ont besoin de droits d'accès au public et les membres d'un objet cible (en fonction de sa classe d'exécution) ou les membres déclarés par une classe donnée

Il comprend les fonctionnalités suivantes.
1. Obtenir les objets de la Classe,
2. L'examen des propriétés d'une classe (champs, méthodes, constructeurs),
3. Réglage et d'obtenir des valeurs de champ,
4. Invoquer des méthodes d',
5. La création de nouvelles instances d'objets.
Jetez un oeil à cette la documentation lien pour les méthodes exposées par Class classe.

De cette l'article (par Dennis Sosnoski, Président, Sosnoski Software Solutions, Inc) et ce l'article (sécurité-explorations pdf):

Je vois beaucoup d'inconvénients que d'utilisations de l'utilisation de la Réflexion

Utilisateur de Réflexion:
1. Il fournit de manière très polyvalente dynamique reliant les composantes du programme
2. Il est utile pour la création de bibliothèques qui travaillent avec des objets de façons très généraux
Inconvénients de Réflexion:
1. Réflexion est beaucoup plus lent que le code directement lorsqu'il est utilisé pour le champ et la méthode d'accès.
2. Il peut masquer ce qui se passe réellement à l'intérieur de votre code
3. Il contourne le code source peut créer des problèmes de maintenance
4. Code de réflexion est également plus complexe que le correspondant direct code
5. Il permet de violation de clé de sécurité Java contraintes telles
  que l'accès aux données de la protection et de sécurité de type
Général abus:
1. Chargement de la restriction de classes,
2. Obtenir des références pour les constructeurs, les méthodes ou les champs d'une classe restreinte,
3. Création de nouvelles instances de l'objet, les méthodes d'invocation, l'obtention ou définissez des valeurs de champ d'une classe restreinte.
Jetez un oeil à cette question SE rapportant à l'abus de la réflexion fonctionnalité:

Comment puis-je lire un domaine privé en Java?

Résumé:

Insécurité utilisation de ses fonctions réalisées à partir de l'intérieur d'un système de code peut aussi facilement conduire à la compromission de la sécurité de Java en model'. Donc utiliser cette fonction avec parcimonie

InformationsquelleAutor Ravindra babu
9

Que le nom lui-même suggère qu'il reflète ce qu'il détient par exemple de la méthode de classe,etc en plus de fournir une fonction à appeler la méthode de la création de l'instance dynamiquement à l'exécution.

Il est utilisé par de nombreux cadres et de l'application sous le bois pour appeler des services sans réellement connaître le code.

InformationsquelleAutor Mohammed Sarfaraz
7

Réflexion vous donne la possibilité d'écrire plus de code générique. Il vous permet de créer un objet au moment de l'exécution et appeler sa méthode au moment de l'exécution. D'où le programme peut être hautement paramétrable. Il permet également à l'introspection de l'objet et de classe afin de détecter ses variables et la méthode exposée à l'extérieur du monde.

InformationsquelleAutor saumik gupta
6

Reflection a beaucoup de utilise. La je suis plus familier avec, est d'être en mesure de créer un code à la volée.

IE: dynamique des classes, des fonctions, des constructeurs basés sur les données
(xml/tableau/sql résultats/codée en dur dans/etc..)
- Cette réponse serait beaucoup mieux si tu donnais juste un exemple inhabituel de code généré à partir d'un SQL résultat ou un fichier XML etc.
- Pas de problème. J'ai utilisé la réflexion dans une application windows qui génère dynamiquement l'interface basée sur XML prises à partir d'une base de données.
- Donc, fondamentalement, il est une classe que j'ai créée qui montre à l'utilisateur un rapport. Ce rapport contient des paramètres tels que la Date(à partir de) id, ou tout autre chose. Cette info est stockée dans le format xml. Alors d'abord, nous avons un rapport de sélection. Sur la base du rapport sélectionné, le formulaire est le xml. Une fois que le xml est récupéré, il utilise la réflexion pour créer une classe avec des champs en fonction reflète types. Une fois que vous changez de rapport, l'ardoise est nettoyé et les nouveaux champs sont générés sur la base xml. De sorte que son essentiellement une forme dynamique basée sur la réflexion. Je l'ai aussi utilisé dans d'autres façons, mais cela devrait être suffecient Espère que ça aide
InformationsquelleAutor Ess Kay
3

Je veux répondre à cette question, par exemple. Tout d'abord Hibernate projet utilise Reflection API pour générer CRUD déclarations à combler le fossé entre l'exécution de l'application et de la persistance. Lorsque les choses changent dans le domaine, le Hibernate a à savoir sur eux, de les conserver à la banque de données et vice versa.

Sinon œuvres Lombok Project. Il a juste injecte du code lors de la compilation, le résultat dans le code insérés dans les classes de votre domaine. (Je crois que c'est OK pour les getters et setters)

Hibernate choisi reflection parce qu'il a peu d'impact sur le processus de construction d'une application.

Et à partir de Java 7, nous avons MethodHandles, qui fonctionne comme Reflection API. Dans les projets, de travailler avec des enregistreurs de nous il suffit de copier-coller le code suivant:
```
Logger LOGGER = Logger.getLogger(MethodHandles.lookup().lookupClass().getName());
```
Parce qu'il est difficile de faire des fautes de frappe-erreur dans ce cas.

InformationsquelleAutor BSeitkazin
3

Que je trouve qu'il vaut mieux expliquer, par exemple, et aucune des réponses ne semblent que...

Un exemple pratique de l'utilisation des reflets serait un Langage Java Serveur écrit en Java ou en PHP, Langage Serveur, écrit en PHP, etc. Language Server donne à votre IDE capacités comme la saisie semi-automatique, saut à la définition, le contexte de l'aide, faisant allusion types et plus. Afin d'avoir tous les noms de balises (mots qui peut être complété automatiquement) pour afficher toutes les correspondances possibles que vous tapez le Langage Serveur doit inspecter tout au sujet de la classe, y compris doc blocs et les membres privés. Pour cela, il a besoin d'une réflexion de ladite classe.

Un autre exemple serait une unité de test d'une méthode privée. Une façon de le faire est de créer une réflexion et un changement de la méthode de portée du public dans le test set-up de phase. Bien sûr, on peut argumenter méthodes privées ne devraient pas être testé directement, mais qui n'est pas le point.

InformationsquelleAutor cprn

Vous devez vous connecter pour publier un commentaire.