notion d'héritageRésolu

Question

Bonjour, je suis en train d'apprendre java, qui est le premier langage de programmation que j'étudie. ma question est plutôt théorique. je suis avec un tutoriel, mais je n'arrive pas à bien comprendre le concept d'héritage via ce tutoriel, avec des recherches sur internet, je vais vous montrer ce que j'ai compris, e c que je n'ai pas compris, afin d'avoir une réponse précise.

j'ai donc compris dans les grosses lignes que l'héritage était une classe qui héritait d'une autre classe, par exemple, un lion fit partie des êtres vivants, ensuite de la faune et enfin des mammifères(pour simplifié). J'écris donc un programme pour le moment pur comprendre la matière. J'ai créer la classe faune (caractéristiques : mammifère ou reptile ou oiseau). J'ai donc créer 3 autres classes avec reptile, oiseau ou mammifère. J'ai donné des caractéristiques différentes pour chaque sous classes de la super classe faune, à chaque fois bien sur accompagné du mot clé extends. Mon but final est qu'une fois que l'utilisateur intégrera un animal, le programme donne les spécificités de cet animal.

Mes questions sont: l'organigramme est fait;
                    mais à quoi cela va me servir? 
                    à quoi cela sert super()?; 
                    Si je dois créer une méthode, montrant les spécialités de l'animal,à quoi cela sert-il que le programme sache qu'il fait partie des reptiles ou des mammifères, ou des oiseaux??

erci pour vos réponses.

cs_Julien39 · Accepted Answer

Bonjour,

Récapitulons, tu as ceci :

+-----------+
|  Faune    |
+-----------+
     ^
     |
+-----------+
| Mamifere  |
+-----------+
     ^
     |
+-----------+
|   Lion    |
+-----------+

Et le but de ton application c'est de donner les caractéristiques des animaux c'est ca ?

Alors oui, là, ca ne sert à rien du tout, je te conseil de créer une classe Animal qui contient toutes les caractéristiques à afficher et le nom de l'animal et c'est réglé.

Je dirais que ce genre d'exemple est fait pour faire comprendre les concepts, et ne permet pas vraiment de comprendre l'utilité des choses. Je vais te donner un exemple qui te fera comprendre plus facilement l'utilité de l'héritage. Laisse moi juste deux minutes pour que j'y réfléchisse.

cs_Julien39 · Answer

On va supposer que tu développes un jeu de courses. Tu peux dans ton jeu piloter soit un avion soit une voiture. Un avion et une voiture peuvent avancer, démarrer, s&#8217;arrêter. L'avion peut monter et descendre et la voiture peut reculer. De plus, l'avion et la voiture ont une image (d'un avion ou d'une voiture) à l'écran.

Dans ce cas tu comprend bien que tes deux véhicules avion et voiture ont un comportement commun qui peut être codé dans une classe Vehicule

Tu as alors le diagramme suivant :
          +------------+
          |  Vehicule  |
          +------------+
          | image      |
          +------------+
          | avancer()  |
          | demarrer() |
          | arreter()  |
          +------------+
           ^        ^
          /          \
         /            \
        /              \
       /                \
 +------------+   +------------+
 |  Voiture   |   |    Avion   |
 +------------+   +------------+
 +------------+   +------------+
 | reculer()  |   | monter()   |
 |            |   | descendre()|
 +------------+   +------------+

Concrètement le constructeur de véhicule sera :
public Vehicule(Image image){
   this.image=image;
}

Le constructeur de Voiture sera :
public Voiture(){
   super(ImageIO.read("imageVoiture.png");
}

Tu comprend ce qu'est le super maintenant ? Un appel au constructeur de la super classe.

cs_Julien39 · Answer

Pour ce qui est de l'utilité, il y en a plusieurs :

Déjà, tu évites la duplication de code et les codes avec les if else (voir polymorpisme)

Ensuite, tu peux de cette manière utiliser une classe Jeu qui prend en paramètre un Véhicule et qui permet de jouer à ton jeu en affichant le bon véhicule : de cette manière, ta classe Jeu et les classes filles de Véhicule ne sont pas liées.

Tu peux ajouter un nouveau véhicule Moto par exemple sans avoir à modifier le code existant.

cs_Julien39 · Answer

Tu as vu, ils sont classes mes diagrammes écrits dans un bloc note (sans jeu de mot)

cs_Stoufy1605 · Answer

Merci beaucoup pour ta réponse, je suis en train d'écrire ce programme pour bien comprendre. Je publierai les codes une fois que j'aurai bien réfléchi au programme. Une fois ce code écris,je ferai une analyse, pourrais-tu me corriger? Afin de surtout voir si j'ai bien tout compris... Je te remercie pour ton aide.

cs_Julien39 · Answer

Je ne sais pas si je pourrai corriger ton travail, un modèle de conception est censé répondre à un besoin, dans ce cas, il n'y a pas de besoin précis et donc pas de solution appropriée...

Si tu souhaite poster ce code, je pense que c'est une mauvaise idée. Fonctionnellement, il ne fait rien, et une classe comme structure de données n'apporte strictement rien. Après, je ne sais pas précisément ce que tu veux faire...

cs_Stoufy1605 · Answer

ok, j'ai pris ton conseil en considération. Effectivement écrire ce programme aurait été une perte de temps! Donc si j'ai bien compris le concept d'héritage, en fait il y a donc des classes et des super classes qui ont des méthodes ainsi que des paramètres. la super classe possède des paramètres communs ainsi que des méthodes communes, ensuite dans les classes filles il y a des paramètres spécifique ainsi que des méthodes spécifiques. Ceci je l'ai bien compris, mais pr conter j'ai encore un peu de mal pour comprendre le super() et le polymorphisme (kesako??)  

Sinon tes diagrammes en bloc notes tiennent du génie!!!!

cs_Julien39 · Answer

Pour le super, il sert à construire un objet en utilisant le constructeur de la super classe, imaginons que tu ais une classe Point2D :

public class Point2D {
   private int x;
   private int y;

   public Point2D(int x, int y){
      this.x=x;
      this.y=y;
   }

   public int getX(){
      return x;
   }

   public int getY(){
      return y;
   }
}

Et ensuite, tu peux créer une classe Point3D, pour éviter la duplication de code, tu utilises ta classe Point2D et tu lui ajoutes une composante z :

public class Point3D extends Point2D {

   private int z;

   public Point3D(int x, int y, int z){
      super(x, y);
      this.z=z;
   }

   public int getZ(){
      return z;
   }
}

Dans ce code super(x, y) et permet d'appeler le constructeur de Point2D pour affecter les valeurs de x et y. 

C'est assez clair avec cet exemple non ?

cs_Julien39 · Answer

Le super() sans paramètre ne sert à rien. Par là, j'entends qu'on est pas obligé de l'écrire, il est automatiquement appelé si aucun super constructeur n'est spécifié. Dans ce cas, le code qui est dans le constructeur sans paramètre de la super classe est quand même exécuté :

public class Mere {
   public Mere(){
      System.out.println("execute");
   }
}

public class Fille extends Mere {
   public Fille(){

   }

   public static void main(String[] args){
      new Fille();
   }
}

cs_Julien39 · Answer

Le polymorphisme, c'est un peu plus complexe à comprendre : l'idée est que tu peux définir plusieurs méthodes différentes pour un même type d'objet. Par exemple, tu créés une interface IVehicule :

public interface IVehicule {
   public String getType();
}

Et tu as plusieurs véhicules :

public class Voiture implements IVehicule {
   public String getType(){
      return "Voiture";
   }
}

public class Camion implements IVehicule {
   public String getType(){
      return "Camion";
   }
}

Quel est l'intérêt maintenant ? Il est énorme. De cette façon, tu vas pouvoir créer des méthodes qui prendront en paramètre un véhicule et non une voiture ou un camion : 

public class Presentation {
   public static void presenter(IVehicule vehicule){
      System.out.println(vehicule.getType());
   }

   public static void main(String[] args){
      Presentation.presenter(new Voiture());
      Presentation.presenter(new Camion());
   }
}

Alors là mon exemple est vraiment pourri, j'espère que tu as compris le principe ? Derrière une même méthode, se cachent des implémentations différentes : voilà comment on peut définir le polymorphisme.

Pour être plus précis, il y a une différence entre polymorphisme et surcharge en langage objet suivant si on fait hériter les classes d'une classe mère éventuellement abstraite ou bien si on implémente la même interface.

cs_Julien39 · Answer

Tu peux regarder le dico, j'avais posté des définitions pour ces deux notions il y a quelques temps : http://www.javafr.com/dico.aspx (elles sont au début)

Notion d'héritage

11 réponses

Votre réponse

Discussions similaires