Discussion :

[Roy Miro]

Bonjour,

J'ai lu sur JavaRanch le topic suivant:

http://www.coderanch.com/t/501804/ja...ed-overloading

... et j'avoue que je ne comprends toujours pas l'explication de l'appel à la méthode

Code :

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

1
2
3
4
 //methObject
static void overloading(Object... o) {  
       System.out.println("Object Var-Args");  
    }

(dans le contexte du post 1).

Dans un des posts qui suivent, un intervenant dit:

Object... method has argument type of Object[] and so it can be called with String[] without using variable arity invocation. Non varargs call is always preffered against varargs call so the Object... method will be used.

Ce que je ne comprends pas est pourquoi "methObject" serait appelée "without using variable arity invocation".

Je crois qu'il sous entend que la nuance vient du fait qu'une méthode ayant pour argument soit Object[] soit Object peut recevoir un paramètre de type String[] (qui est un tableau d'Objects mais aussi simplement un Object). Je suis d'accord sur ce point mais où cela mène t-il?

Merci vivement de votre aide.

[tchize_]

en "gros" ça viens des règles java pour trouver la méthode qui s'applique, et avec les var-arg, en très gros (j'ai pas envie de sortire les détail, c'est dans le java langage specification), c'est difficile, voir impossible dans l'état actuel du language, de faire de l'overloading sur des méthodes à argument variable*.

Donc tu aura des problèmes avec

public void meth(Object[].... argument)
public void meth(String[].... argument)
public void meth(Object.... argument)


conclusion, pour les méthodes surchargée, éviter d'en avoir plusieurs avec argument variable, le choix n'est pas toujours aussi instinctif qu'on le voudrait


* j'entends par là faire de l"overloading en ayant un choix naturel des méthodes ad-hoc, le compilo luin il suit la logique du language, mais sur les opérateurs surchargé ça amène des trucs qui ont pas l'air naturels.

[adiGuba]

Salut,


En cas de surcharge de méthode, le compilateur va rechercher la méthode la plus adapté selon le type de ses paramètres, ou générer une erreur si il trouve une ambiguïté.

Toutefois l'expansion des varargs survient après une première recherche. En effet les varargs sont en fait des tableaux (pour des raisons de compatibilités entre autres), donc lorsque tu as ceci :

Code :

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

1
2
void overloading(String[]... s)
void overloading(Object... o)

En réalité tu as ceci :

Code :

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

1
2
void overloading(String[][] s)
void overloading(Object[] o)

Du coup lorsque tu fais appel à cette méthode avec un tableau :

Code :

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

1
2
         String[] aa = new String[2];  
         overloading(aa);

Le compilateur va ignorer la première méthode (String[] n'est pas compatible avec String[][]), alors que la seconde est correcte (String[] est compatible avec Object[]).

La décomposition en varargs n'est faite qu'après si aucune méthode "standard" ne correspond à notre appel, ce qui n'est pas le cas ici.


a++

PS : Tout ceci c'est surtout pour le principe : il vaut mieux éviter toutes surcharges qui pourrait apporter des ambiguïtés comme cela... varargs ou pas

[Roy Miro]

Bonjour,

Merci à vous deux pour vos réponses

Je ne mets pas le sujet résolu au cas où certains auraient des explications complémentaires.
J'espère qu'il n'y aura pas de questions de ce genre pour l'exam de la SCJP

[Roy Miro]

Re bonjour

Toutefois l'expansion des varargs survient après une première recherche. En effet les varargs sont en fait des tableaux [...]

En réalité tu as ceci :
Code :

Code :

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

1
2
void overloading(String[][] s)
void overloading(Object[] o)

Ok, les var-args pouvent être imaginés comme des tableaux (éventuellement vide).

D'après ce qui a été dit, après "extension des var args", un paramètre de type String[] correspondra avec l'argument de type Object[] et non String[][] ce qui est logique.

Et c'est peut être aussi pour cela qu'un des intervenants indique que la méthode

Code :

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

1
2
//methode écrite par le développeur:
void overloading(Object o)

correspondra à un appel "without using variable arity invocation", raison pour laquelle elle est appelée. En effet, après expansion des var arg, on a la méthode "généree"

Code :

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

void overloading(Object[] o)

que la JVM appelle en passant un (exactement un) String[] d'où la non arité évoquée. Tandis que si, c'est l'autre méthode qui est appelée , on aurait éventuellement un [][]String vide (si la JVM avait appelé la méthode sans aucun paramètre) d'où la notion d'arité qui apparait.

Au final l'appel sans arité est privilégié.

Mes questions maintenant sont:
1) Ma compréhension de la chose vous parait-elle juste?

2) J'ai l'impression que cet overloading non trivial est spécifique au fait qu'on passe un tableau et vous?

Merci d'avance encore une fois

[Alain Defrance]

Le var args *sont* véritablement des tableau, et ils sont transformés à à la compilation. Un petit article qui pourra t'aider (en anglais par contre) : http://alaindefrance.wordpress.com/2...pilation-time/

[Roy Miro]

Le var args *sont* véritablement des tableau, et ils sont transformés à à la compilation.

Bonjour,

Merci pour l'article (très clair par ailleurs)

Grâce à vos réponses, les choses paraissent plus évidentes maintenant.
Donc les var args c'est piegeux avec les tableaux. Y a-t-il d'autre types d'objets qui soulèvent des questions de ce type?

Merci encore et bonne soirée!