Discussion :

[Oromis56]

Hey !

Ce sujet n'est pas vraiment une demande d'aide mais plus une demande d'avis de personnes plus expérimentées sur ce langage.
Voilà, il y a quelques mois, j'ai découvert la réflexion, et depuis, je l'utilise assez régulièrement. Je trouve cela pratique de pouvoir manipuler des fonctions et des classes de la même façon qu'un objet, et donc adaptée à la création de structure pour des petits programmes.
Supposons un programme générant une liste en faisant varier certains paramètres.

Par exemple, on donne pour entrée :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Cette ligne contient #nombre# 'a' : #lettre#

Générant cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
Cette ligne contient 1 'a' : a
Cette ligne contient 2 'a' : aa
Cette ligne contient 3 'a' : aaa
Cette ligne contient 4 'a' : aaaa
Cette ligne contient 5 'a' : aaaaa

La balise #nombre# de l'exemple a donc été paramétrée de façon à incrémenter le nombre précédent de 1 en partant de 1 et #lettre# de répéter 'a' une fois de plus à chaque ligne.
Ici, le programme propose donc deux possibilités d'évolution du paramètre : incrémentation et multiplication d'un string.
Je trouve que dans ce genre de conditions, la réflexion peut être utile, il suffirait que la fonction s'occupant de créer la liste finale prenne en paramètre les méthodes à appeler (donc ici, incrémentation et multiplication) pour générer convenablement la sortie. Aussi, si l'on souhaite ajouter une nouvelle possibilité d'évolution, il suffirait de créer la nouvelle méthode indépendamment et de la passer à son tour en paramètre si besoin. Ainsi, il n'y a pas besoin d'apporter de modification brute dans le code de génération du rendu et l'ajout en est donc plus simple.

Mais voilà, je sais que la réflexion est quelque chose de lourd, et donc que cette façon de voir les choses n'est peut-être pas la bonne. Je voudrais donc votre avis sur la (sur ?)utilisation de la réflexion, peut-être quelques conseils sur la bonne utilisation de cette dernière dans ce genre de situation et sur la flexibilité d'un programme, et éventuellement des alternatives que se soit dans la réflexion (pas celle de Java cette fois-ci), ou dans la technique !

Je vous remercie par avance !

[yildiz-online]

La reflexion ne doit être utilisée en java que dans des cas très spécifiques, et bas niveau, dans des librairies par exemple.

Elle détourne le principe d'encapsulation, et donc invalide le paradigme principal pour lequel est prévu java.
La bonne manière d'ajouter des fonctionnalités et de prévoir un canvas modulaire et défini pour l'interface des fonctions et utiliser le polymorphisme, possiblement en sus d'un service loader pour charger la feature dynamiquement.

si tu veux ajouter des fonctions à la volée simplement, java n'est pas le langage pour faire ça, tourne toi plutôt vers un langage plus permissif à ce sujet comme le javascript ou le ruby.

[adiGuba]

Salut,


La reflexion est totalement inutile dans ce cas, et même un peu contre-productif (c'est lourd à mettre en place pour ce que cela apporte).
Si tu veux simplement "passer" une fonction en paramètre, il te suffit de définir une interface représentant cette fonction.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
    public interface Operator {
      public int nextValue(int previousValue);
    }
 
    public static void repeat(char letter, int start, int end, Operator operator) {
 
		for (int i = start; i < end; i = operator.nextValue(i)) {
          	char[] letters = new char[i];
          	Arrays.fill(letters, letter);
          	String line = new String(letters);
			System.out.println("Cette ligne contient " + i + " '" + letter + "' : " + line);
    	}
    }

D'autant plus depuis Java 8 où tu peux utiliser les expressions lambdas ou les références de méthode :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
    repeat('a', 1, 10, x->x+1 );
 
    repeat('b', 1, 100, x->x*3 );
 
    repeat('c', 1, 100, MyClass::multiplyBy2 );

a++

[Oromis56]

Je vous remercie tout les deux !
Je vais me renseigner un peu sur le ServiceLoader donc !

@adiGuba, en effet, je pense voir comment tu veux faire avec les interfaces, ce qui me bloquait était le fait que, dans cet exemple, les méthodes représentant l'évolution d'une balise (#xxx#) ne prennent pas nécessairement les mêmes paramètres d'entrée, et je ne savais donc contourner véritablement ce problème..

Sinon, effectivement, je ne pense pas assez aux lambda expression, à voir après s'ils permettent de résoudre mon problème cité ci-dessus !

[adiGuba]

Je n'ai peut-être bien compris ce que tu voulais, mais en l'état je ne vois pas forcément d'avantage à utiliser la réflection...