[OBJET] paramètres optionels en quantité indéterminée, constructeurs de classe
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:
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:
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:
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 :D
À 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:
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 !
