Exécuter automatiquement une méthode

**zakips** · 06/03/2016, 01h28

Salut,

Il existe en C un moyen pour créer un tableau de fonctions; ce tableau sert par la suite à appeler les méthodes en donnant l'indice de la case.

J'aimerais savoir s'il existe en Java ce genre de traitement et comment le faire ?

Je connais la notion de réflexivité de Java où on peut récupérer les méthodes d'une classe, mais le problème est que le tableau retourné contient toutes les méthodes et je ne peux pas calculer l'indice des méthodes.

Quelqu'un saurait-il m'indiquer comment faire ?

Merci d'avance pour votre aide.

**joel.drigo** · 06/03/2016, 02h52

Salut,

Regarde du côté des expressions lamdas de Java 8 (Cela dépend des méthodes à appeler : ont-elles toutes les mêmes paramètres ? Ces paramètres sont-ils fixés ?). On peut les mettre en tableau, List, Map...

Exemple de principe :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
public class Exemple {
 
	public void method1(int p) {
		  System.out.println("method1 "+p);
	}
 
	public void method2(int p) {
		  System.out.println("method2 "+p);
	}
 
 
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.function.BiConsumer;
 
public class Program {
 
	private static final BiConsumer<Exemple, Integer> METHOD1_CALL = (o,p)-> o.method1(p);
	private static final BiConsumer<Exemple, Integer> METHOD2_CALL = (o,p)-> o.method2(p);
 
 
	@SuppressWarnings("unchecked")
	public final static BiConsumer<Exemple, Integer>[] METHODS = new BiConsumer[]{
			METHOD1_CALL, METHOD2_CALL
		};
 
 
	public static void main(String[] args) {
 
		Exemple exemple = new Exemple();
 
		METHODS[0].accept(exemple, 15);
		METHODS[1].accept(exemple, 25);
 
	}
 
}

Si aucune des interfaces fonctionnelles du package java.util.function te convient, tu peux te créer ta propre interface fonctionnelle (une interface avec une seule méthode (hormis les méthodes défault).

Exemple de principe, avec un enum au lieu d'un tableau (mais on peut utiliser une enum comme tableau éventuellement, avec la méthode values()) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
public enum PathType {
 
	TRUC(Tester.TRUC),
	TRUC_MACHIN(Tester.TRUC,Matcher.MACHIN);
 
	public enum Response {
		STARTS_WITH,
		EQUALS,
		NO
	}
 
	private final Tester[] testers;
	private PathType(Tester...testers) {
		this.testers=testers;
	}
 
	public Response in(Path path) {
 
		if ( testers.length>path.getNameCount() ) {
			return Response.NO;
		}
 
		for(int i=0; i<testers.length; i++) {
			if ( !testers[i].test(path.getName(i)) ) {
				return Response.NO;
			}
		}
		return path.getNameCount()==testers.length?Response.EQUALS:Response.STARTS_WITH;
 
	}
 
 
	@FunctionalInterface
	private static interface Tester {
 
		final static Tester TRUC = path-> "truc".equals(path);
 
		boolean test(String path);
 
		default boolean test(Path path) {
			return test(path.toString());
		}
 
	}
 
	@FunctionalInterface
	private static interface Matcher extends Tester {
 
		final static Pattern PATTERN = Pattern.compile("^a.*");
		final static Matcher MACHIN = ()-> PATTERN;
 
		Pattern pattern();
 
		default boolean test(String path) {
			return pattern().matcher(path).matches();
		}
 
	}
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
switch( PathType.TRUC_MACHIN.in( containerPath.relative(monPath) ) ) {
  case NO:
   /*... */ 
   break;
 case EQUALS:   
   /*... */ 
   break;
 case STARTS_WITH:   
   /*... */ 
   break;
}

**bouye** · 06/03/2016, 23h28

Avant le JDK 8 :

Tableau (ou liste) d'instance de classes implementant une interface définissant la méthode à invoquer.
Ou tableau (ou liste) de java.lang.reflect.Method qui seront invoquée via la réflexion (vaut aussi passer une référence vers une instance si c'est une méthode d'instance).

Après le JDK 8 :