Surcharge d'une classe interne d'une classe héritée

Version imprimable

Bonjour,

J'essaye de définir une classe Modele qui doit me servir pour différentes classes qui devraient en hériter et comportant une classe interne de la façon suivante :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 public class Modele { private ClasseInterne monObjCI; private class ClasseInterne { public ClasseInterne() { super(); } } public getMonObjCI() { return monObjCI; } public Modele() { super(); this.monObjCI = new ClasseInterne(); }
Et dans chacune de mes classes héritées, je n'aurais "plus qu'à" redéfinir ma classe interne spécifique à chacune de mes classes comme celà :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 public class ClasseHeritee extends Modele { private class ClasseInterne { private int monChamp1; private String monChamp2; public setMonChamp1 (int monChamp1) { this.monChamp1 = monChamp1; public setMonChamp2 (String monChamp2) { this.monChamp2 = monChamp2; } }
Le problème est que je n'arrive pas à affecter les différentes valeurs à mes champs dans un objet de la classe héritée de la façon suivante :
Code:

1 2 3 ClasseHeritee monObj = new ClasseHeritee(); // Je pensais faire comme celà mais ça ne fonctionne pas !!! monObj.getMonObjCI().setMonChamp1(3);
Et peut on réellement le faire de cette façon ?

D'avance merci.

14/01/2013, 12h27
thelvin

Citation:

Envoyé par 3Fred9

Et peut on réellement le faire de cette façon ?

Non. On ne peut pas redéfinir une classe, on ne peut redéfinir que des méthodes.

Cela ne s'appelle pas non plus de la surcharge, mais juste un masquage. Une classe A qui porte le même nom qu'une autre classe B, empêche juste de voir B là où on voit A. Il n'y a pas de lien entre les deux, elles ont juste le même nom et donc ce nom ne peut désigner qu'une seule des deux.

Pour faire ce que tu demandes, tes classes internes doivent elles aussi hériter d'une classe commune. Elles seront alors libres d'avoir leurs propres méthodes, et de redéfinir les méthodes communes s'il y en a.

Chaque classe qui hérite de Modele peut redéfinir getMonObjCI() de sorte que ça renvoie le bon type.

Et l'instance de ClasseInterne à utiliser, pourrait être passée par le constructeur des classes filles de Modele, au constructeur de Modele, qui donc ne se charge pas de l'instancier lui-même. Cela permet à chaque classe fille d'avoir chacune son propre type de classe interne, et de l'exposer au monde.

Merci pour cette première réponse.

Si j'ai tout compris, ce qui m'étonnes car j'ai encore un problème . Je sors donc la classe interne pour en faire une classe à part entière :
Code:

1 2 3 4 5 public class ClasseDuModele { public ClasseDuModele() { super(); } }
Ma classe Modele devient donc :
Code:

1 2 3 public class Modele { public ClasseDuModele monObjCI; }
Ma classe fille devient donc :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public class ClasseHeritee extends Modele { public class ClasseInterne extends ClasseDuModele { private int monChamp1; private String monChamp2; public ClasseInterne(int monChamp1, String monChamp2) { this.monChamp1 = monChamp1; this.monChamp2 = monChamp2; } public ClasseHeritee(ClasseInterne monObjCI) { super(); this.monObjCI = monObjCI; } }
Et dans l'utilisation :
Code:

1 2 ClasseInterne monObjInterne = new ClasseHeritee.ClasseInterne(1, "Bonjour"); ClasseHeritee monObj = new ClasseHeritee(monObjInterne);
Or là j'ai le problème sur le new ClasseHeritee.ClasseInterne qui si je comprends bien me demande q'une instance de ClasseHeritee existe afin d'appeler le constructeur de ClasseInterne or le constructeur de ClasseHeritee a besoin de monObjInterne donc je tourne en rond.... :cry:

Puis ce que j'ai du mal à saisir c'est comment monObjetInterne puisse passer de type ClasseDuModele au type ClasseInterne sans aucune surcharge ???

D'avance merci.

14/01/2013, 16h13
thelvin
Citation:

Envoyé par 3Fred9

Je sors donc la classe interne pour en faire une classe à part entière :

T'étais pas obligé, hein. Ça marche, mais rien ne t'y oblige. On peut tout-à-fait étendre une classe interne.
Citation:
Envoyé par 3Fred9

Et dans l'utilisation :

Code:

1 2 ClasseInterne monObjInterne = new ClasseHeritee.ClasseInterne(1, "Bonjour"); ClasseHeritee monObj = new ClasseHeritee(monObjInterne);
Euh, non, plutôt revoir le constructeur de ClasseHeritee :
Code:

1 2 3 4 5 6 7 8 public ClasseHeritee() { super(makeMonObjInterne()); } private ClasseInterne makeMonObjInterne() { this.monObjInterne = new ClasseInterne(); return this.monObjInterne; }
Et encore, si ça se trouve tu as pas besoin de l'envoyer au super() pour la classe mère. Auquel cas, c'est bien plus simple.

Citation:

Envoyé par 3Fred9

Puis ce que j'ai du mal à saisir c'est comment monObjetInterne puisse passer de type ClasseDuModele au type ClasseInterne sans aucune surcharge ???

Parce que toutes les classes filles feront un appel de new LaClassInterneDeCetteFille()
14/01/2013, 16h37
3Fred9

OK ça marche nickel !!!!

Merci encore à toi

Suite...

De nouveau bonjour,

Alors cette fois j'ai un petit soucis au niveau du contructeur pour une autre classe interne, je m'explique...

J'ai donc ma classe Modele suivante (avec une deuxième classe interne que j'ai du coup repassé à l'intérieur de ma classe Modele)
Code:

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 27 public class Modele { protected int monAttribut; public ClasseDuModele1 monObjCi1; public ClasseDuModele2 monObjCi2; public class ClasseDuModele1 { public ClasseDuModele1() { super(); } } public class ClasseDuModele2 { public ClasseDuModele2() { super(); } } public Modele(int monAttribut) { super(); this.monAttribut = monAttribut; } public void maMethode() { this.monObjCi2 = new ClasseDuModele2(); } }
Puis ma classe héritée suivante :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 public class ClasseHeritee extends Modele { public class ClasseInterne1 extends ClasseDuModele1 { private int monChamp1Ci1; private String monChamp2Ci1; public ClasseInterne1(int monChamp1Ci1, String monChamp2Ci1) { super(); this.monChamp1Ci1 = monChamp1Ci1; this.monChamp2Ci1 = monChamp2Ci1; } public class ClasseInterne2 extends ClasseDuModele2 { private int monChampCi2; public ClasseInterne2(int monChampCi2) { super(); this.monChampCi2 = monChampCi2; } public ClasseHeritee(int monChamp1Ci1, String monChamp2Ci1) { super(); this.monObjCi1 = new ClasseInterne1(monChamp1Ci1, monChamp2Ci1); } }
Et donc l'utilisation de la classe héritée de cette façon :
Code:

1 2 monObj = new ClasseHeritee(1, "Bonjour"); monObj.maMethode();
monObj possède bien un objet monObjCi1 de ClasseInterne1 (qui est construit dans le constructeur de ClasseHeritee...

Par contre mon problème se trouve dans la construction de monObjCi2 qui se construit dans la fonction maMethode de la classe Modele qui est construit suivant la classe ClasseDuModele2 et non ClasseInterne2 :cry:

Je pensais que le fait d'appeler maMethode sur monObj (de classe ClasseHeritee) allait automatiquement prendre en surcharge le contructeur de ClasseInterne2 au lieu de ClasseDuModele2 mais ce n'est pas le cas...

Y aurait il donc un moyen de réaliser ceci ? Ou bien ai je mal définit maMethode ?

Encore merci pour votre aide...

1) Soit tu es occupé d'essayer de comprendre comment marche le language en allant dans le fond des trucs bizarre => ok on va expliquer ce qui pose problème

2) Soit tu essaie vraiment de résoudre un problème réel, et là t'es occuper de méchament sur complexifier ton travail :?

Cas n°1

C'est bien simple, maMethode fait un new ClasseDuModele2(), il n'y a pas de raison que tu te retrouve avec autre chose à l'arrivée, que magiquement elle décide d'instancier autre chose. Comme on l'a dit, il n'y a pas de surcharge des classe. Imagine simplement "si c'était le cas" et que tu avais deux classes dans ClasseHeritee qui héritaient de ClasseDuModele2, il devrait prendre laquelle?

Le classe interne, ce n'est jamais qu'une hierarchie particulière, on peux avoir exactement le même comportement en mettant la classe dehors. C'est juste plus chiant à coder, et en faisant une classe interne, le compilateur te facilite le travail sur toute une série de trucs, comme le référencement de la classe externe, la création des accesseurs, etc.

Pour résoudre ton problème, il faudrait surcharger maMethode() dans la classe héritée pour qu'elle crée un objet interne de la classe Héritée.

Cas 2:

Oublie les class interne, il n'est pas nécessaire d'ailleur que chaque classe héritée aie son propre lot de class interne. Utilise avantageusement la covariance pour te simplifier tes classes.
Code:

1 2 public interface Interface1{...} public interface Interface2{...}
Code:

1 2 3 4 5 6 7 8 9 10 11 public abstract class AbstractModele{ protected int monAttribut; public Interface1 monObjCi1; public Interface1 monObjCi2; public AbstractModele(int monAttribut) { super(); this.monAttribut = monAttribut; } public abstract Interface2 makeObjectCi2(); }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 public class Modele extends AbstractModele{ public class ClasseDuModele1 {....} public class ClasseDuModele2 {....} public Modele(int monAttribut) { super(monAttribut); } @Override public ClasseDuModele2 makeObjectCi2(){ return new ClasseDuModele2(); } }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 public class ClasseHeritee extends Modele { public class ClasseInterne1 extends ClasseDuModele1 {....} public class ClasseInterne2 extends ClasseDuModele2 {....} } public ClasseHeritee(int monChamp1Ci1, String monChamp2Ci1) { super(monChamp1Ci1); this.monObjCi1 = new ClasseInterne1(monChamp1Ci1, monChamp2Ci1); } @Override public ClasseInterne2 makeObjectCi2(){ return new ClasseInterne2(69); } }
Et encore, on pourrais encore vachement plus se simplifier la tâche avec les generics je pense, mais sans savoir la finalité de l'algo

Bonjour,

Alors pour être clair, je me trouve bien dans le deuxième cas, j'ai volontairement banalisé et simplifié mon code afin que tout le monde puisse adapter ce code dans le cas où il se trouverait dans la même situation... et que celà ne soit pas trop lourd à la lecture... alors voilà mon cas que j'essaye de traduire par une classe Java.

J'ai des programmes RPGILE, appelons les GS, (dans mon exemple GSHerite) possédant la même structure et qui hérite donc toujours d'un même programme GSModele définissant cette structure commune.

Ces GS possèdent tojours un attribut nomPgm et les régions suivantes :
- input1 avec des variables différentes dans les GS qui hérite de GSModele
- input2 toujours avec les mêmes variables monAttribut1 et monAttribut2 dans les GS qui hérite de GSModele
- output avec des variables différentes dans les GS qui en hérite et qui contient un tableau d'enregistrements renvoyé par les fonctions GS.

Ces régions étant propres à ces fonctions GS, il me semblait naturel qu'elles soient représentées en classes internes à ma classe modèle GSModele...

Cette classe GSModele représente donc un programme AS400 RPGILE avec des variables en Input et une variable en Output

Voici donc le programme que j'essaye donc de transcrire en classe modèle afin que chacun des programmes qui en hérite aient la même structure :

Code:

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
public class GSModele {
 
   protected String nomPgm="";
   protected ModeleInput1 input1;
   protected ModeleInput2 input2;
   protected ModeleOutput[] output;
 
   public class ModeleInput1 {
      protected String nomInput1;
 
      public ModeleInput1(String nomInput1) {
         super();
         this.nomInput1 = nomInput1;
      }
   }
 
   public class ModeleInput2 {
      protected String nomInput2;
      protected String nomMonAttribut1;
      protected int monAttribut1;
      protected int monAttribut2;
 
      public ModeleInput2(String nomInput2, String nomMonAttribut1, int monAttribut1, int monAttribut2) {
         this.nomInput2 = nomInput2;
         this.nomMonAttribut1 = nomMonAttribut1;
         this.monAttribut1 = monAttribut1;
         this.monAttribut2 = monAttribut2;
      }
   }
 
   public class ModeleOutput {
      protected String nomOutput;
 
      public ModeleOutput(String nomOutput) {
         super();
         this.nomOutput = nomOutput;
      }
   }
 
   public GSModele(String nomPgm) {
      super();
      this.nomPgm = nomPgm;
   }
 
   // Cette fonction représente l'appel au programme et doit construire le tableau des enregistrements en Output sachant que ce code est indifférent pour tout les GS qui héritent de GSModele si ce n'est les variables qui compose l'Output.
   public void CallPgm() {
      // Je simplifie ici volontairement le code pour un soucis de lisibilité
      String codeRetour = "";
      while (codeRetour.equals("")) { 
         codeRetour = Appel du programme AS400
         // Récupération du nombre d'enregistrements retournés par l appel
         int nbrEnregistrements = Nbre retourné par l appel
         if (nbrEnregistrements != 0) {
            // Récupération et construction de Output
            output = new ModeleOutput[nbrEnregistrements];
            for (int i = 0; i < nbrEnregistrements; i++) {
               output[i] = new ModeleOutput();
            }
        }
   }
 
   public ModeleOutput[] getOutput {
      return output;
   }
 
}

Et voici mon GSHeritee pour l'exemple :

Code:

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
27
28
29
30
31
32
33
34
35
36
37
public class GSHeritee extends GSModele {
 
   public class Input1 extends ModeleInput1 {
      private int maVar1Input1;
      private int maVar2Input1;
 
      public Input1(int maVar1Input1, int maVar2Input1) {
         super("nomInput1DansGSHeritee");
         this.maVar1Input1 = maVar1Input1;
         this.maVar2Input1 = maVar2Input1;
   }
 
   public class Input2 extends ModeleInput2 {
 
      public Input2(int monAttribut1, int monAttribut2) {
         super("nomInput2DansGSHeritee", "nomAttribut1DansGSHeritee", monAttribut1, monAttribut2);
   }
 
   public class Output extends ModeleOutput {
      private int maVar1Output;
      private int maVar2Output;
      private int maVar3Output;
 
      public Output() {
         super("nomOutputDansGSHeritee");
         this.maVar1Output = récuperation maVar1Output de l appel à la fonction;
         this.maVar2Output = récuperation maVar2Output de l appel à la fonction;
         this.maVar3Output = récuperation maVar3Output de l appel à la fonction;
      }
   }
 
   public GSHeritee(int maVar1Input1, int maVar2Input1, int monAttribut1, int monAttribut2) {
      super("nomPgmGSHeritee");
      this.input1 = new Input1(maVar1Input1, maVar2Input1);
      this.input2 = new Input2(monAttribut1, monAttribut2);
   }
}

Et donc dans l'utilisation de ma fonction GSHeritee :

Code:

1
2
3
GSHeritee monGS = new GSHeritee(1, 2, 3, 4);
monGS.CallPgm();
monGS.getOutput();

Donc mon probleme est que lorsque j'appelle monGS.CallPgm(), cette fonction me construit la variable output suivant la classe ModeleOutput et non Output de mon GSHeritee...

Je sens bien qu'il manque quelque chose pour que celà fonctionne... mais quoi ?

Voilà j'espère avoir été plus concret... et d'avance merci à vous tous.

ok, on oublie modele1 et 2 qui n'ont rien à voir avec ton problème pour se simplifier la lecture

Ton problème, basiquement, est le suivant

Tu as une class GSModele, avec un méthode qui crée des ModeleOutput (ModeleOutput[]) et tu as une class héritée, GSHeritee, qui devrait à la place sortir des Output extends ModeleOutput

Il te suffit d'utiliser la covariance et le generics pour ça (et accessoirement plutot des List parce que les arrays et les generics, ça fait pas toujours bon ménage et j'ai pas envie de vérifier ce cas ci)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 public abstract class GSModele<T extends ModeleOutput>{ protected List<T> output = new ArrayList<T>; public class ModeleOutput {...} public abstact T createOutput(); public List<T> getResult() {return output;} public void CallPgm() { // Je simplifie ici volontairement le code pour un soucis de lisibilité String codeRetour = ""; while (codeRetour.equals("")) { codeRetour = Appel du programme AS400 // Récupération du nombre d'enregistrements retournés par l appel int nbrEnregistrements = Nbre retourné par l appel if (nbrEnregistrements != 0) { // Récupération et construction de Output for (int i = 0; i < nbrEnregistrements; i++) { output.add(createOutput()); } } } }
Code:

1 2 3 4 5 public class GSHeritee extends GSModele<Output>{ public class Output extends ModelOutput{...} public T createOutput(){ return new Output();} }
Code:

1 2 3 4 GSHeritee prog = new GSHeritee(.....); prog.callPgm(); List<GSHeritee.Output> resultat = prog.getResult();
Accessoirement, vu leur code, tes inner classe n'ont pas besoin d'être des inner class, car leur code n'a pas besoin d'accéder à leur conteneur. Je te recommande de les faire sortir et d'organiser par exemple ton project comme ceci:
Code:

1 2 3 4 com.company.gs.modele com.company.gs.input com.company.gs.output
Ce sera moins lourd à suivre dans le code :)

18/01/2013, 11h21
3Fred9
Bonjour,

Alors j'ai encore un petit soucis avec mon Output, si je déclare ma classe de cette façon :
Code:

1 2 3 4 5 public abstract class GSModele<T extends ModeleOutput> { protected List<T> output = new ArrayList<T>(); public class ModeleOutput {...} ... }
J'ai le problème ModeleOutput cannot be resolved to a type

Si je sors la déclaration de la classe ModeleOutput de mon GSModele, là j'ai plus de soucis sur la classe GSModele... par contre dans le GSHeritee lorsque je code :
Code:

1 2 3 4 public class GSHeritee extends GSModele<Output>{ public class Output extends ModelOutput{...} public T createOutput(){ return new Output();} }
et ben là j'ai le même problème que précédemment mais sur le <Output> :cry:

Encore merci pour votre aide...
18/01/2013, 11h35
tchize_

Effectivement, un Generic ne peux pas dépendre de lui même et je suppose que c'est pareil pour les inner class, je n'avais pas testé le code avant de l'envoyer.

Peux être que mettre Output en static résoudrais le problème, mais le mieux reste de le garder dehors selon moi :)

Pas mieux avec :

Code:

1
2
3
4
public class  GSHeritee extends  GSModele<Output>{
   public static class Output extends ModelOutput{...}
   public T createOutput(){ return new Output();}
}

Mais je m'en suis sorti en sortant également mon Output (devenu GSOutput), j'ai donc :

Code:

1
2
public class ModeleOutput {
}

Code:

1
2
public abstract class  GSModele <T extends ModeleOutput> {
}

Code:

1
2
public class GSOutput extends ModeleOutput {
}

Code:

1
2
3
4
public class  GSHeritee extends GSModele<GSOutput> {
   public class Output extends GSOutput {
   }
}

Ouf... :mouarf:

Encore merci à tous :ccool:

18/01/2013, 13h15
thelvin
Citation:
Envoyé par 3Fred9

Pas mieux avec :

Code:

1 2 3 4 public class GSHeritee extends GSModele<Output>{ public static class Output extends ModelOutput{...} public T createOutput(){ return new Output();} }
Ça marche avec

Code:

public class GSHeritee extends GSModele<GSHeritee.Output>

Ça marche aussi sans le static.

Je ne sais pas pourquoi le GSHeritee. n'est pas implicite, je trouve pas ça très bon. Mais il y a peut-être une bonne raison.

De toute façon sortir la classe interne rend les choses plus simples.