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 !