Choix de la bonne méthode

Version imprimable

Bonjour, j'étudie un programme avec deux classes: "VueSwing" et "VueJFX" (exactement les même IHM, la seul diff est la bibliotheque utilisée) héritant de "ControleurVue" (classe abstraite). Les classes filles remonte les actions utilisateur a la classe mére en utilisant un ID pour différencier les actions.
VueSwing:
Code:

1 2 3 4 5 6 7 8 public void actionPerformed(ActionEvent e) { if (c == startConnexionbutton) { actionUser(1); } else if (c == stopConnexionButton) { actionUser(2); } }
Vue JavaFX:
Code:

1 2 3 4 5 6 7 8 9 public void initialize(URL arg0, ResourceBundle arg1) { startConnexionbutton.setOnMouseReleased(mouseEvent -> { actionUser(1); }); stopConnexionButton.setOnMouseReleased(mouseEvent -> { actionUser(2); }); }
ControleurVue:
Code:

1 2 3 4 5 6 7 8 9 10 11 public void actionUser(int idAction) { switch (idAction) { case 1: connection(); break; case 2: deconnection(); break; } }
La méthode "connection()"" appel une méthode abstraite "refreshNumeroCE()"" de "ControleurVue".
Code:

1 2 3 4 5 6 private void connection(){ refreshNumeroCE(); } public abstract void refreshNumeroCE();
Logique, cette méthode est définie dans "VueSwing" et "VueJFX" avec un body différent.
J'ai fait un test et java choisi la bonne méthode (refreshNumeroCE() définit dans VueJFX ou définit dans VueSwing) en fonction de l'IHM sur la quelle l'utilisateur a cliquer et je n'arrive pas a comprendre comment.
Pouvez vous m'aider ?

Salut,

C'est le principe même de l'héritage et de la redéfinition de méthode. La notion d'abstraction ne fait qu'insérer dans la hiérarchie une classe non instanciable, avec certaines méthodes éventuellement non définie, et qui permet de manipuler toutes les instances de type spécifique par un même type.

Un exemple plus simple :
Code:

1 2 3 4 5 public class abstract Vehicule { public abstract int getNombreDeRoues(); }
Code:

1 2 3 4 5 6 7 public class Moto extends Vehicule { public int getNombreDeRoues() { return 2; } }
Code:

1 2 3 4 5 6 7 public class Voiture extends Vehicule { public int getNombreDeRoues() { return 4; } }
Code:

1 2 3 4 5 Vehicule voiture = new Voiture(); Vehicule moto = new Moto(); System.out.println("Nombre de roues de voiture : " + voiture.getNombreDeRoues()); System.out.println("Nombre de roues de moto : " + moto.getNombreDeRoues());
Affiche :
Nombre de roues de voiture : 4
Nombre de roues de moto : 2
Dans le code, à la compilation, on manipule voiture et moto par le type Vehicule, donc on peut appeler la méthode getNombreDeRoues() pour les deux instances : ça compile.
Mais concrètement, à l'exécution, voiture est une instance de Voiture, donc le code exécuté est celui de la méthode getNombreDeRoues() de la classe Voiture, et ça retourne donc 4.
Et concrètement, à l'exécution, moto est une instance de Moto, donc le code exécuté est celui de la méthode getNombreDeRoues() de la classe Moto, et ça retourne donc 2.

Merci joel.drigo pour ton explication mais une chose me turlupine toujours:
dans l'exemple que tu as donnée, il y a:
Code:

1 2 3 System.out.println("Nombre de roues de voiture : " + voiture.getNombreDeRoues()); System.out.println("Nombre de roues de moto : " + moto.getNombreDeRoues());
Ici on sait a qui on a affaire mais comment le sait-on dans ?
Code:

1 2 3 4 private void connection(){ refreshNumeroCE(); }

C'est l'instance elle-même "qui le sait".

Si je modifie mon exemple :

Code:

1
2
3
4
5
6
7
8
9
public class abstract Vehicule {
 
   public abstract int getNombreDeRoues();
 
   public String toString() {
          return "Nombre de roues : " + getNombreDeRoues();
   }
 
}

Code:

1
2
3
4
5
Vehicule voiture = new Voiture();
Vehicule moto = new Moto();
 
System.out.println("voiture, " + voiture);
System.out.println("moto, " + moto);

va afficher :

voiture, Nombre de roues : 4
moto, Nombre de roues : 2

La méthode toString() de Vehicule va être appelée lors de l'exécution sur l'instance de Voiture (héritage), et cette méthode va appeler la méthode getNombreDeRoues de la classe concrête de l'instance (redéfinition), soit Voiture, donc l'implémentation qui retourne 4.

Et si j'écris :

Code:

1
2
3
4
5
6
7
8
9
10
11
public class Moto extends Vehicule {
 
   public int getNombreDeRoues() {
         return 2;
   }
 
   public String toString() {
            return "Moto, " + super.toString();
   }
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
public class Voiture extends Vehicule {
 
   public int getNombreDeRoues() {
         return 4;
   }
 
   public String toString() {
            return "Voiture, " + super.toString();
   }
 
}

Code:

1
2
3
4
5
Vehicule voiture = new Voiture();
Vehicule moto = new Moto();
 
System.out.println(voiture);
System.out.println(moto);

va afficher :

Voiture, Nombre de roues : 4
Moto, Nombre de roues : 2

03/02/2017, 09h32
Abraxe

Merci, je comprend mieux maintenant !!! :D