Discussion :

[Invité]

Bonsoir,
Dans le cadre d'un projet, je dois réaliser un logiciel en JAVAFX qui permet de simuler des capteurs selon différents algorithmes.
Le problème, c'est que ces algorithmes héritent tous d'une classe abstraite SensorAlgoChanger et je veux récupérer toutes les classes qui héritent de cette classe abstraite de la manière suivante :

Dans SensorAlgoChanger, j'ai une méthode statique nommée getSons et c'est cette méthode que je veux implémenter pour récupérer les classes qui héritent.

Mon professeur m'a parlé d'introspection mais j'avoue être complètement étranger à ce terme et après plusieurs recherches Internet, je ne suis pas plus avancé.

Avez-vous une solution ou une piste pour solutionner mon problème ?

Merci de vos réponses.

[joel.drigo]

Salut,

1. L'approche par réflexion
   La réflexion te permettra d'instancier des classes si tu connais leur nom, pas de découvrir les classes existantes, encore moins de connaître les classes qui étendent une abstraction.
   
   Tu peux faire ça facilement avec la bibliothèque Reflections.
   
   Par exemple, si j'ai les classes suivantes :
   
   
   • abstract class my.package.AbstractTruc
   • class my.packages.A extends my.packages.AbstractTruc
   • class my.packages.B extends my.packages.AbstractTruc
   • class my.packages.C extends my.packages.AbstractTruc
   
   
   

   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
   public class Exemple {
    
   	public static void main(String[] args) {
    
   		Reflections reflections = new Reflections("my.packages");
    
   		Set<Class<? extends AbstractTruc>> subTypes = reflections.getSubTypesOf(AbstractTruc.class);
    
   		for(Class<?> c : subTypes) {
   			System.out.println(c.getName());
   		}
    
   	}
    
   }

   Affichage :
   

   my.packages.A
   my.packages.B
   my.packages.C

   Mes classes sont déclarées comme ça :
   
   
   
   

   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
   package my.packages;
   public abstract class AbstractTruc {
    
   	private int value;
   	private String string;
    
   	public AbstractTruc(int value) {
   		this.value=value;
   	}
    
   	public AbstractTruc(int value, String string) {
   		this.value=value;
   		this.string=string;
   	}
    
   	@Override
   	public String toString() {
   		return "["+value+","+string+"]";
   	}
    
   }

   Code :

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

   1
   2
   3
   4
   5
   6
   7
   8
   9
   package my.packages;
    
   public class A extends AbstractTruc {
    
   	public A(int value) {
   		super(value);
   	}
    
   }

   Code :

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

   1
   2
   3
   4
   5
   6
   7
   8
   9
   package my.packages;
    
   public class B extends AbstractTruc {
    
   	public B(int value, String string) {
   		super(value,string);
   	}
    
   }

   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
   package my.packages;
    
   public class C extends AbstractTruc {
    
   	private int other;
    
   	public C(int value, int other) {
   		super(value);
   		this.other=other;
   	}
    
   	public C(int value, String string, int other) {
   		super(value,string);
   		this.other=other;
   	}
    
   	@Override
   	public String toString() {
   		return "["+super.toString()+","+other+"]";
   	}
    
   }

   
   
   Pour instancier les classes par réflexion :
   

   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
    
    
   import java.lang.invoke.MethodHandle;
   import java.lang.invoke.MethodHandles;
   import java.lang.invoke.MethodHandles.Lookup;
   import java.lang.invoke.MethodType;
   import java.util.Set;
    
   import org.reflections.Reflections;
    
   public class Exemple {
    
   	public static void main(String[] args) {
   		Reflections reflections = new Reflections("my.packages");
    
   		Set<Class<? extends AbstractTruc>> subTypes = reflections.getSubTypesOf(AbstractTruc.class);
    
   		Lookup lookup = MethodHandles.publicLookup();
   		for (Class<?> c : subTypes) {
   			System.out.println(c.getName());
   			try {
   				MethodHandle constructor = lookup.findConstructor(c, MethodType.methodType(void.class, int.class));
   				AbstractTruc instance = (AbstractTruc) constructor.invoke(0);
   				System.out.println("With constructor (int) " + instance);
   			} catch (NoSuchMethodException e) {
   				System.out.println("No constructor (int)");
   			} catch (Throwable e) {
   				e.printStackTrace();
   			}
   			try {
   				MethodHandle constructor = lookup.findConstructor(c,
   						MethodType.methodType(void.class, int.class, String.class));
   				AbstractTruc instance = (AbstractTruc) constructor.invoke(0, "test");
   				System.out.println("With constructor (int,String) " + instance);
   			} catch (NoSuchMethodException e) {
   				System.out.println("No constructor (int,String)");
   			} catch (Throwable e) {
   				e.printStackTrace();
   			}
   			try {
   				MethodHandle constructor = lookup.findConstructor(c,
   						MethodType.methodType(void.class, int.class, String.class, int.class));
   				AbstractTruc instance = (AbstractTruc) constructor.invoke(0, "test", 1);
   				System.out.println("With constructor (int,String,int) " + instance);
   			} catch (NoSuchMethodException e) {
   				System.out.println("No constructor (int,String,int)");
   			} catch (Throwable e) {
   				e.printStackTrace();
   			}
    
   		}
    
   	}
    
   }

   Affichage :
   

   my.packages.A
   With constructor (int) [0,null]
   No constructor (int,String)
   No constructor (int,String,int)
   my.packages.B
   No constructor (int)
   With constructor (int,String) [0,test]
   No constructor (int,String,int)
   my.packages.C
   No constructor (int)
   No constructor (int,String)
   With constructor (int,String,int) [[0,test],1]
   

2. L'approche sans réflexion
   Si tu connais les classes concernées, tu peux gérer le problème sans réflexion. Par exemple, avec une enum :
   

   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
   import java.util.function.Supplier;
    
   public class Exemple {
    
   	public enum Factory implements Supplier<AbstractTruc> {
   		A("A(int)") {
   			public A get() {
   				return new A(0);
   			}
    
   		},
   		B("A(int,String)") {
   			public B get() {
   				return new B(0,"test");
   			}
   		},
   		C_1("C(int,int)") {
   			public C get() {
   				return new C(0, 1);
   			}
   		},
   		C_2("C(int,String,int)") {
   			public C get() {
   				return new C(0, "test", 1);
   			}
   		},
   		;
    
   		public final String type;
   		private Factory(String type) {
   			this.type=type;
   		}
    
   	}
    
   	public static void main(String[] args) {
   		for(Factory factory : Factory.values()) {
   			System.out.println(factory.type);
   			System.out.println("--> "+factory.get());
   		}
   	}
    
   }

[Invité]

Merci pour votre réponse.
Cela me paraît très étrange qu'il n'existe aucun moyen de faire cela en JAVA.
Je vais essayer votre solution mais je doute que ce soit la solution attendue

[joel.drigo]

Cela me paraît très étrange qu'il n'existe aucun moyen de faire cela en JAVA.

Bah, on peut le faire en Java. La bibliothèque dont je parle est écrite en Java. Le code n'est pas si simple, il faut tenir compte de beaucoup de choses pour que ça fonctionne dans tous les cas. Autant utiliser une bibliothèque qui fait ça.
La plupart du temps on n'a pas besoin de le faire : soit on utilise explicitement le nom des classes, ou des fabriques, soit on utilise des services (lookup), on utilise éventuellement de la réflexion avec nom explicite (String). Lorsqu'on sait à l'écriture de la classe qu'on va avoir besoin de lookup, on peut utiliser différentes techniques (registration, annotation, aspect...), mais ça implique un code spécifique dans la classe.
Ce genre de découvertes automatiques est rarement utile en run, c'est pourquoi il n'y a pas d'utilitaires inclus dans le JDK qui le fait.

Je vais essayer votre solution mais je doute que ce soit la solution attendue

[thelvin]

Cela me paraît très étrange qu'il n'existe aucun moyen de faire cela en JAVA.

Ça va pourtant de soi avec le système de chargement de Java qui ne lie une classe que si on en a besoin.
Pour faire ce que tu demandes, il faut lier toutes les classes qui puissent être trouvées dans le classpath et vérifier quelles sont leurs classes parentes. C'est extrêmement inefficace et ça a causé de nombreux problèmes à résoudre quand des bibliothèques populaires ont commencé à le faire quand même.

D'ailleurs, normalement il n'est même pas prévu de pouvoir connaître toutes les classes trouvables. Un peu comme un site web ne va pas donner la liste de toutes les URLs qui peuvent être visitées.

[Invité]

Merci pour vos réponses finalement j'ai demandé au professeur qui m'a juste conseillé de notifier la classe mère dans un bloc statique.