Parametre variables en nombre et en type

Version imprimable

18/04/2007, 15h41
tinico

Parametre variables en nombre et en type
Bonjour a tous,

Voila mon petit probleme : Je suis sous java 1.4 !! :lol:

Je voudrais un moyen de regrouper tous les parametres passés à une méthode dans une hashtable sans le faire manuellement.

Je veux donc récupérer les parametres et les passer à une méthode hérité qui me renvoi une hashtable avec tous les parametres dedans. Le problème est que la méthode qui fait ça doit etre générique et doit donc fonctionner avec différente signature...

Pour ceci, il me faudrait un truc du style :
Code:

1 2 hashtable mamethode(Object... param)
Mais je suis sous java 1.4, donc, pas possible... Mais il me faudrait un truc pour faire comme ci !!

Merci beaucoup !! ;)
18/04/2007, 15h45
g0up1l

Si tous tes paramètres héritent de Object, tu peux passer à ta méthode un Vector d'objets 'Object'
18/04/2007, 15h51
adiGuba

Salut,

Citation:

Envoyé par g0up1l

Si tous tes paramètres héritent de Object, tu peux passer à ta méthode un Vector d'objets 'Object'

Ou tout simplement un tableau :

Code:

mamethode(Object[] param)

Que tu appeleras ensuite de la manière suivante :

Code:

mamethode(new Object[]{ param1, param2, param3, param4 } );

C'est ce qui se rapproche le plus de l'ellipse de Java 5.0...

a++
18/04/2007, 15h57
tinico
Citation:

Envoyé par adiGuba

Ou tout simplement un tableau :

Code:

mamethode(Object[] param)

Que tu appeleras ensuite de la manière suivante :

Code:

mamethode(new Object[]{ param1, param2, param3, param4 } );

Je vais proposer ça, Merci bien !!
Malheureusement, je pense que c'est pas possible autrement...

Je supose que trouver un moyen ou on utiliserait directement :
Code:

1 2 mamethode(param1, param2, param3, param4)
C'est pas possible ??
18/04/2007, 16h01
®om
Citation:
Envoyé par tinico

Code:

1 2 mamethode(param1, param2, param3, param4)

C'est pas possible ??
C'est pour ça que l'ellipse a été ajoutée... Donc sans l'ellipse, non...
18/04/2007, 16h02
chtig

Ah ben non pas en 1.4 c'est justement à ça que sert l'ellipse ...

Edit : eh zut trop lent :(
18/04/2007, 16h04
tinico

Je m'en doutais un peu, mais je preferais avoir confirmation !!

Ok, et bien, si cela est le plus simple, je valide !!!

MERCI BEAUCOUP pour votre efficacité et votre rapidité (surtout) :yaisse2:

Salut,

Une autre solution serait d'utiliser une classe qui engloberait les paramètres pour les stocker dans une List, par exemple :

Code:

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
public class VarArg {
 
	// Liste des paramètres
	private List paramList = new ArrayList();
 
	// Constructeur privée pour empêcher les créations directes
	private VarArg() {
 
	}
 
	// Méthode statique d'intialisation
	public static VarArg init(Object arg) {
		return new VarArg().add(arg);
	}
 
	// Ajout de paramètre :
	public VarArg add(Object arg) {
		this.paramList.add(arg);
		return this;
	}
 
	// package-view pour empêcher d'utiliser la méthode
	List getParamList() {
		return paramList;
	}
}

Et avec une méthode du style :

Code:

1
2
3
4
5
6
7
8
9
10
11
	public void method(VarArg vararg) {
		if (vararg!=null) {
			Iterator iterator = vararg.getParamList().iterator();
			while (iterator.hasNext()) {
				Object param = iterator.next();
 
				// Traitement du paramètre 
 
			}
		}
	}

On peut l'utiliser de la manière suivante :

Code:

obj.method( VarArg.init(param1).add(param2).add(param3).add(param4) );

Mais ce n'est pas forcément plus lisible...

a++

18/04/2007, 16h35
tinico

oula oui !!

C'est meme moins lisible !! hi hi
Je pense que je vais rester sur ma premiere solution, elle me parrait plus sure et plus lisible !

Merci quand meme

Citation:

Envoyé par tinico

oula oui !!

C'est meme moins lisible !! hi hi

J'avais prévenu :P

Cette solution à toutefois quelques avantages (tant que j'y suis je développe ;)) :
Elle permet de définir des restrictions sur les types autorisé sans pour autant qu'il y ait de relation entre les deux. Par exemple si on souhaite accepter seulement les type String et Date il suffit d'utiliser la surcharge de méthode, par exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 // Ajout de paramètre (private pour qu'elle ne puisse pas être utilisé directement: private VarArg addObject(Object arg) { this.paramList.add(arg); return this; } // On autorise l'ajout de paramètre de type String public VarArg add(String arg) { return this.addObject(arg); } // On autorise l'ajout de paramètre de type Date public VarArg add(Date arg) { return this.addObject(arg); }
Elle permet également de gérer les types primitives de manière transparente (en gérant une espèce d'autoboxing). Ceci encore une fois avec la surcharge de méthode :
Code:

1 2 3 4 // Ajout de paramètre de type int : public VarArg add(int arg) { return add(new Integer(arg)); }
Mais il faut également dire que la première solution a un gros avantage : elle sera très facile à migrer vers Java 5.0 !!!

Exemple de code Java 1.4 :
Code:

1 2 3 public void method(Object[] args) { ... }
Qui est appelé comme cela :

Code:

obj.method( new Object[] { param1, param2, param3, param4 } );

Et pour pouvoir utiliser l'ellipse de Java 5.0 il suffira de modifier la déclaration du tableau dans la méthode :

Code:

public void method(Object... args) {

Comme l'ellipse est en fait un tableau il n'y aura rien à changer dans le code de la méthode, et on pourra alors utiliser la syntaxe courte :

Code:

obj.method( param1, param2, param3, param4 );

Mais le principal avantage vient du fait que l'ancienne syntaxe continuera de fonctionner sans problèmes :

Code:

obj.method( new Object[] { param1, param2, param3, param4 } );

Il sera inutile de modifier tous les appels de méthodes existants ;)

a++