Discussion :

[tinico]

Bonjour a tous,

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

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 :

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

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 !!

[g0up1l]

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

[adiGuba]

Salut,

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 :

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

mamethode(Object[] param)

Que tu appeleras ensuite de la manière suivante :

Code :

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

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

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

a++

[tinico]

Ou tout simplement un tableau :

Code :

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

mamethode(Object[] param)

Que tu appeleras ensuite de la manière suivante :

Code :

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

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 :

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

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

C'est pas possible ??

[®om]

Code :

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

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...

[chtig]

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

Edit : eh zut trop lent

[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)

[adiGuba]

Salut,


Une autre solution serait d'utiliser une classe qui engloberait les paramètres pour les stocker dans une List, par 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
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 :

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

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 :

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

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

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

a++

[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

[adiGuba]

oula oui !!

C'est meme moins lisible !! hi hi

J'avais prévenu


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 :

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

  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 :

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

  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 :

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

1
2
3
	public void method(Object[] args) {
		...
	}

Qui est appelé comme cela :

Code :

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

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 :

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

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 :

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

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

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

Code :

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

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

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

a++