Discussion :

[jmini]

Bonjour,

Je cherche à proposer différentes options pour l’exécution d’un programme. Pour simplifier mettons qu’il s’agit de 3 manières (manière 1, manière 2, manière 3) de faire un calcul.

Pour le moment je fonctionne comme cela :

J’ai une énumération qui défini les manières disponibles :

Code :

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

public enum ManieresDeCalcul {MANIERE_1, MANIERE_2, MANIERE_3}

Et dans ma classe principale j’ai une fonction calcule() qui attend la manière comme paramètre. Dans cette méthode, à l’aide d’un switch, j’utilise la méthode qui me convient :

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
public int calcule(ManieresDeCalcul maniere) {
	int resultat;
	resultat = 0;
 
	switch(maniere) {
	case MANIERE_1 :
		//code pour la maniere de calcul 1 => resultat
		break;
	case MANIERE_2 :
		//code pour la maniere de calcul 2
		break;	
	case MANIERE_3 :
		//code pour la maniere de calcul 3
		break;
	}
 
	return resultat;
}

Première question : s’agit t’il d’une bonne méthode pour résoudre ce type de problème ou y a t’il d’autre moyen plus élégant ?


* * *

Ensuite, j’aimerais avoir la possibilité d’avoir un comportement par défaut. Il me semble que cela ne pose pas de problème, je n’ai qu’à avoir la même méthode sans paramètres :

Code :

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

1
2
3
public int calcule() {
	return calcule(ManieresDeCalcul.MANIERE_1);
}

(en considérant que la MANIERE_1 est celle par défaut)

* * *

Maintenant je souhaiterais pouvoir définir quelle va être la méthode par défaut à utiliser (un fichier texte me semble assez approprié).

Il me semble que Java propose un mécanisme de fichier Properties pour répondre à ce type de problème.

S'agit il d'une bonne idée (sinon comment faire autrement) ?
Où puis je trouver un exemple, ou de la doc pour en savoir plus ?

Est-ce que dans le fichier properties je peux forcer le fait de devoir avoir une valeur contenue dans une énumération (ou faut-il que je refasse un mapping de type String -> Valeur de l’Enum)


Je voudrais utiliser une méthode standard et utilisée par tous, histoire d'éviter de réinventer une roue qui doit déjà exister en standard...


Merci

[rebel64]

Autres solutions...
Commence par définir une interface de calcul que tu implémentes dans une classe séparée pour chaque manière de calcul:

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
 
public interface ManiereDeCalcul {
	int calcul();
}
 
public class ManiereDeCalcul1 implements ManiereDeCalcul {
	public int calcul() {
		// TODO Premiere maniere de calcul
		return 1;
	}
}
 
public class ManiereDeCalcul2 implements ManiereDeCalcul {
	public int calcul() {
		// TODO 2e Premiere maniere de calcul
		return 2;
	}
}

Pour choisir le bon calcul en fonction de son nom tu peux utiliser une Map<String,ManiereDeCalcul> chargée statiquement...

Code :

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

1
2
3
4
5
6
7
8
9
import java.util.HashMap;
 
public class MapCalculs extends HashMap<String, ManiereDeCalcul>{
	public MapCalculs() {
		put("ManiereDeCalcul1",new ManiereDeCalcul1());
		put("ManiereDeCalcul2",new ManiereDeCalcul2());
		//...etc...
	}
}

Tu peux aussi utiliser ton propre ClassLoader...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
public class CalculClassLoader extends ClassLoader {
	public ManiereDeCalcul getManiereDeCalcul(String maniere) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
		Class<?> c=loadClass(maniere);
		return (ManiereDeCalcul)c.newInstance();
	}
}
public class Calcul {
	int calcul(String nom) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
		return new CalculClassLoader().getManiereDeCalcul(nom).calcul();
	}
}

Cà donne ...

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 static void main(String[] args) {
	// Appels via une Map 
	MapCalculs mapCalculs=new MapCalculs();
	System.out.println(mapCalculs.get("ManiereDeCalcul1").calcul());
	System.out.println(mapCalculs.get("ManiereDeCalcul2").calcul());
 
	// Appels via un classLoader
	try {
		System.out.println(new Calcul().calcul("ManiereDeCalcul1"));
		System.out.println(new Calcul().calcul("ManiereDeCalcul2"));
	} catch (Exception e) {
		e.printStackTrace();
	} 
}

[dingoth]

En mille fois plus simple : les enum SONT des classes (spéciales, certes, mais des classes quand même).

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
public enum ManieresDeCalcul {
  MANIERE_1 {
    public int calcul (String parametrePourCalcul) {
      return 1;
    }
  },
  MANIERE_2 {
    public int calcul (String parametrePourCalcul) {
      return 2;
    }
  },
  MANIERE_3 {
    public int calcul (String parametrePourCalcul) {
      return 3;
    }
  };
 
  public abstract int calcul (String parametrePourCalcul);
}

Et la méthode calcule (ManieresDeCalcul) :

Code :

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

1
2
3
4
public int calcule (ManieresDeCalcul mdc) {
  String monParam = "mon param";
  int resultat = mdc.calcul(monParam);
}

On en profite pour éviter un switch ET une surcharge de classes (même si implicitement, il y en a).

[jmini]

Je vois que c'etait pas une question si stupide...

Comment avec la méthode de dingoth, je peux stocker dans un fichier de paramétrage (a priori du texte) quelle doit être celle a utiliser par défaut ?

Est ce que là aussi il y un moyen de retrouver de quel élément de l'énumération on parle ?

J'imagine qu'il y a mieux que de faire :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
ManieresDeCalcul mdc;
String mdcParDefaut;
// on recherche (dans un fichier de config) la valeur par defaut -> mdcParDefaut
if(mdcParDefaut.contentEquals("MANIERE_1")) {
   mdc = ManieresDeCalcul.MANIERE_1;
} else if(mdcParDefaut.contentEquals("MANIERE_2")) {
   mdc = ManieresDeCalcul.MANIERE_2;
} else if(mdcParDefaut.contentEquals("MANIERE_3")) {
   mdc = ManieresDeCalcul.MANIERE_3;
}
 
return mdc;

Merci pour vos réponses.

.

[dingoth]

Certainement, il y a mieux, et toujours grâce aux enum !

Code :

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

1
2
3
4
5
6
ManieresDeCalcul mdc;
String mdcParDefaut;
// on recherche (dans un fichier de config) la valeur par defaut -> mdcParDefaut
 
mdc = ManieresDeCalcul.valueOf(mdcParDefaut); 
return mdc;

Et paf, encore 5 lignes de parties !

[hibour]

dingoth je vois que vous apprécier énormément les enum
Sinon à part les enum tu peux construire une application configurable à l'aide d'un fichier properties où

Code :

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

1
2
3
default=classe d'implémentation par défault
maniere1=classe d'implémentation 1
maniere2=classe d'implémentation 2

Les classes d'implémentation doivent implémenter une certaine interface

Code :

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

1
2
3
public insterface IManiere {
 void calcul(Object param);
}

Une classe Manager qui charge le properties et qui fait grosso modo

Code :

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

1
2
IManiere maniere = (IManiere) Class.forName(properties.get(maniere));
maniere.calcul(XXX);