Discussion :

[cotmar]

Bonjour,

J'aurais une petite question : est il possible de passer des paramètres de manières optionnels à une foction Java ?

Si jamais celà n'était pas possible, comment faire autrement ?

Sinon, dans le cas où le sujet existerat déjà, je vous prie de m'excuser, mais malgrè une recherche sur le Forrum et le FAQ, je n'ai rien trouvé sur ce sujet... Si jamais il existe déjà, je vous prie d em'excuser.

Par avance je vous remercie.

Marco.

[leyee]

Non il n'est pas possible d'avoir des parametres optionnels au sens où tu les entend : par contre rien dne t'empeche de passer en parametre un tableau ou une collection d'Object pour simuler ce comportement

[djo.mos]

FAQ Java nombre variable de paramètres.
Sinon tu peux toujours redéfinir ta méthode avec des signatures différents.

Bonne chance.

[Delwyn]

Pour poursuivre également, rien ne t'empeche de passer un pointeur null à ta fonction.

Tu as également la solution de surcharger ta méthode et de la décliner suivant plusieurs types d'appel, et pour eviter de dupliquer le code tu peux appeler une méthode privée commune de tes méthodes surchargées.

[edit:ouned par modjo ]

[adiGuba]

Salut,

Tu as également la solution de surcharger ta méthode et de la décliner suivant plusieurs types d'appel, et pour eviter de dupliquer le code tu peux appeler une méthode privée commune de tes méthodes surchargées.

+1

Mais tu n'as pas forcément besoin d'une méthode privée.
Il suffit de coder la méthode qui prend le maximum de paramètre, par exemple :

Code :

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

1
2
3
4
5
public void method(String param1, Date param2, int param3) {
	// Cette méthode fait tout le travail 
	// ...
	// ...
}

Et d'ensuite la surcharger avec les versions "allégées" en paramètres, qui se contenteront en fait de l'appeler :

Code :

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

1
2
3
4
5
6
7
public void method(String param1, Date param2) {
	method(param1, param2, 0);
}
 
public void method(String param1) {
	method(param1, new Date());
}

Cela te permet de "simuler" le mécanisme de paramètre par défaut, en "enlevant" à chaque fois un paramètre...







Maintenant, si tu as un très grand nombre de paramètre, et que tu veux fournir des valeurs par défaut à différents paramètres quel que soit leurs emplacements, tu peux utiliser l'idiome des "paramètres nommées", en utilisant en fait un seul paramètre qui les regroupera tous :

Code :

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

1
2
3
public void method(MethodParam param) {
   // ...
}

Et où MethodParam est une classe qui propose des méthodes pour définir chacun des paramètres, exemple :

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
class MethodParam {
 
	String param1;
	Date param2 = null;
	int param3 = 0;
 
	/** Constructeur privée : utiliser la méthode static create */
	private MethodParam(String param1) { 
		// empty
	}
 
	public static MethodParam create(String param1) {
		return new MethodParam(param1);
	}
 
	public MethodParam param2(Date param2) {
		this.param2 = param2;
		return this;
	}
 
	public MethodParam param3(int param3) {
		this.param3 = param3;
		return this;
	}
}

La méthode static create() permet de créer une nouvelle instance (en obligeant la présence d'un paramètre), et les autres méthodes paramX() permettent de définir les autres paramètres optionnels. Ces méthode retourne l'instance this afin de pouvoir enchainer les appels.

Ainsi à l'utilisation tu peux avoir quelque chose du genre :

Code :

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

1
2
3
4
	method( MethodParam.create("test") );
	method( MethodParam.create("test").param2(new Date()) );
	method( MethodParam.create("test").param2(new Date()).param3(0) );
	method( MethodParam.create("test").param3(0) );

a++

[cotmar]

Bonjour à tous,

Merci de toutes ces réponses. Finalement, je vais certainement utiiser la méthode de la surcharge...

En fait mon projet a été généré automatiquement par un outil qui s'appelle JavaCC (pour faire un parser).

La méthode que je souhaite modifier est appelée un peut partout dans mon programme et ne voudrais pas avoir à tout réécrire.

Maintenant, je ne sais pas si c'est vraiment la bonne solution... Sachant que en fait dans cette histoire je ne souhaite pas traiter les premières lignes du fichier d'origine et que là dedans comme il s'agit d'un parser, le programme me décompose les mots de "vocabulaire" qu'il rencontre dans le fichier d'origine.

J'espère que je suis bien clair en fait ?

Par avance merci les amis.

Marco.