Discussion :

[Eleectraz]

Salut salut !

Voilà tout d’abord je me présente brièvement : je code en Java depuis peu, mais j'ai déjà codé en d'autres langages ( Python principalement ). Pour ce qui est de Java on me l'enseigne actuellement à la fac, mais les cours ne sont pas très avancés et j'ai décidé de les devancer par moi-même : je me suis mis alors à suivre le tuto . J'en ai fini avec la partie "Java Orienté Objet", et actuellement je me lance dans la création de classes personnalisées.


Enfin bref. Voilà mon problème : je voudrais définir une méthode qui de base s'appellerait avec un tableau en entrée ( public void maMethode (Type[] args) en gros ), mais qui par soucis de simplicité accepterais aussi les appels du genre maMethode(arg1,arg2,...,argN). J'ai pensé à surcharger ma méthode de la manière suivante, mais cela ne permet qu'un nombre fini de possibilité concernant le nombre d'argument, et est sacrément redondant !

Code Java :

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
public void maMethode (Type[] args) {
  ... // le corps principal de la méthode
}
public void maMethode () {  // SURCHARGE AVEC 0 ARGUMENT
  Type[] args = new Type[0];
  maMethode(args);
}
public void maMethode (Type arg1) {  // SURCHARGE AVEC 1 ARGUMENT
  Type[] args = {arg1};
  maMethode(args);
}
...                          // ETC
public void maMethode (Type arg1, Type arg2, Type arg3, Type arg4, Type arg5) {  // SURCHARGE AVEC 5 ARGUMENTS
  Type[] args = {arg1,arg2,arg3,arg4,arg5};
  maMethode(args);
}

En fait si vous m'avez compris ce que je voudrais c'est avoir une surcharge de méthode définie à la volée qui serait utilisée lorsqu'on appellerait la fonction avec n arguments ( de type défini ). En Python ça donnerait ça :

Code Python :

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

1
2
3
4
5
def maMethode(self,*args):
    if len(args) and type(args[0])==type([]):
        args=args[0]
    # ce "if" est presque inutile : on pourrait appeler simplement "obj.maMethode(*args)"
    ... # le corps principal de la méthode

Mais en Java je vois vraiment pas... Enfin j'ai une piste : y aurait-il moyen de créer à la demande de telles méthodes, avec l'aide du package java.lang.reflect par exemple. Et si oui, comment ? J'ai bien essayer de regarder les différentes méthodes de la classe Class avec le bout de code suivant ( repris du tuto ), mais les méthodes retournées n'ont l'air d'être que des accesseurs ( beaucoup de get...() et de is...() ), et non pas des mutateurs.

Code Java :

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

1
2
3
4
5
6
7
import java.lang.reflect.Method;
...
Method[] m = Class.class.getMethods();
System.out.println("Il y a "+m.length+" méthodes dans la class 'Class'.");
for(int i = 0; i < m.length; i++) {
  System.out.println(m[i].getName());
}

Et pourtant il suffirait de redéfinir la méthode getMethod de la classe de maClasse lorsque appelé avec les arguments "maMethode", arg1, arg2, arg3... , et ensuite d'invoquer la méthode définie premièrement, à savoir public void maMethode (Type[] args).

Et c'est là que je me met à tâtonner et à m'enfoncer dans l'ombre, j'espère que quelqu'un saura éclairer ma lanterne


À ce problème la viennent se rajouter quelques subtilités : en fait la méthode maMethode sera un constructeur de maClasse, et la classe maClasse sera une classe abstraite de laquelle dériverons plusieurs classes filles ( non abstraites ). Je voudrais ainsi avoir le code mis une seule fois dans la classe mère sans avoir à redéfinir le constructeur surchargé à nombre d'argument indéterminé dans chacune des classes filles... J'ai essayé de surcharger le constructeur avec final mais ça ne marche pas Je suis prêt à définir une méthode secondaire utilisée lors de la construction, pour n'avoir à redéfinir que cette méthode par la suite, comme ceci :

Code Java :

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

1
2
3
4
5
6
7
8
9
public abstract class MaClasse {
  protected Type[] references;
  protected void init() {} // redéfini par les classes filles, au besoin
  public MaClasse (Type[] refs) {
    this.references=refs;
    this.init();
  }
  // que mets-je ici ?
}

Voilà voilà ! Merci d'avance pour votre aide !

[tchize_]

Ce sont des varargs que tu cherche, tout simplement:

Code :

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

1
2
3
4
5
6
public static void taMethode (Type... args){
     System.out.println("Il y a "+args.length+" arguments");
     for (Type type: args) {
        System.out.println("Et un argument: "+type);
     }
}

Code :

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

1
2
3
4
5
taMethode(type1);
taMethode(type2);
taMethode(type1,type2);
Type[] tableau = ???????;
taMethode(tableau);

Ca s'applique aussi bien aux constructeur d'ailleurs.

[Eleectraz]

Merci beaucoup, tchize_ ! Voilà un point syntaxique que je ne connaissait pas... En tout cas ça simplifie vraiment la vie : je peux tout à fait envisager de redéfinir la méthode dans les classes filles maintenant, avec simplement

Code Java :

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

1
2
3
4
5
6
7
8
public class SousClasse extends MaClasse {
 
  public SousClasse (Type... args) {
    super(args);
    // éventellement du code ici...
  }
 
}

Merci encore !

[Eleectraz]

Aheum désolé... j'ai continué mon programme et une question dans le même genre se pose : comment régler d'avance la taille du nombre d'argument avec Type... ? J'aurai un cas où les classes filles doivent redéfinir une variable de classe de type int définissant le nombre d'arguments que le constructeur de la classe fille doit accepter, et donc ce nombre varie d'une sous classe à l'autre ?

Enfin je peux aussi tout simplement avoir besoin de mettre tous les arguments du constructeur de la classe fille dans un tableau pour l'envoyer à la méthode constructrice mère : super(tabArgs). Ça simplifie le problème vu que le nombre de paramètres n'est pas stocké dans une variable, mais c'est le même concept... Comment faire ?

[tchize_]

Tu ne peux pas, le principe du vararg, c'est justement qu'il remplace un tableau.

[joel.drigo]

Oui, enfin, tu peux faire (si c'est ce que tu cherches à faire) :

Code :

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

1
2
3
4
5
6
7
public class Class1 {
 
    public Class1(int...param) {
 
    }
 
}

Code :

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

1
2
3
4
5
6
7
public class Class2 extends Class1 {
 
    public Class2(int param1, int param2, int param3, int param4, int param5, int param6, int param7) {
         super(param1, param2, param3, param4, param5, param6, param7);
    }
 
}

Code :

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

1
2
3
4
5
6
7
public class Class3 extends Class1 {
 
    public Class3(int param1, int param2, int param3) {
         super(param1, param2, param3);
    }
 
}

[Eleectraz]

Oh bah cette dernière solution m'ira alors... vu que en général ce sera 1, 2 ou 3 arguments ça passera largement. Je devrais pouvoir me débrouiller par la suite, merci à vous deux !