Différences

Ci-dessous, les différences entre deux révisions de la page.

--- bloc2:prog:poo:classesabstraites [2023/03/29 14:58] – ↷ Nom de la page changé de bloc2:prog:poo:classeabstraites à bloc2:prog:poo:classesabstraites admin
+++ bloc2:prog:poo:classesabstraites [2023/04/11 12:00] (Version actuelle) – [Concept] admin
@@ Ligne 12: / Ligne 12: @@
 Exemple :
-<code=java>// une classe abstraite A
+<code java A.java>
+// une classe abstraite A
 public abstract class A
 {
@@ Ligne 23: / Ligne 24: @@
     public abstract void autreMethode (int nombre) ;
 }
+</code>
+<code java B.java>
+// une classe qui dérive la classe abstraite A
+public class B extends A
+{
+    // implémentation de la méthode abstraite de A : obligatoire,
+    // sinon B reste abstraite
+    public void autreMethode (int param) {
+        ...
+    }
+}
+// instanciation d'une classe qui dérive une classe abstraite : OK
+B b = new B (...) ;
 </code>
 ===== Bénéfices =====
   * On peut placer dans une **classe abstraite** toutes les **fonctionnalités** dont on souhaite disposer dans ses **classes dérivées**, sans pour autant définir leur **fonctionnement interne**;
   * On peut utiliser des **classes abstraites** pour simplement empêcher qu’une classe ne soit **instanciée** parce que son existence en tant que classe est **uniquement technique** et ne repose pas sur le besoin de manipuler l’objet en tant que tel.
+===== Règles de construction =====
+  * Dès qu’une classe comporte une ou plusieurs méthodes abstraites, elle est abstraite, même si on ne l’indique pas avec le mot-clé « abstract » dans sa définition.
-===== Comment les utiliser =====
+  * Une classe qui hérite d’une classe abstraite n’est pas tenue de redéfinir toutes les méthodes abstraites (elle peut n’en définir que certaines). Dans ce cas elle demeure elle-même abstraite.
-=== Définir la classe en Abstract Class. ===
+===== Exemples d'utilisation =====
-{{bloc2:prog:poo:abstract.png}}
+=== Définir une classe abstraite ===
-Il n'est plus possible de l'instancier, la méthode **print** ne fonctionne donc plus.
+<code=java>
-Il faut à présent laisser les méthodes dans la super-classe.
+public abstract class Classe_A {
+    ...
+}
+</code>
+=== Définir des méthodes abstraites ===
+<code=java>
+public  class Classe_A {
+    // Bien observer ici qu'il s'agit d'une signature de méthode :
+    //    + Pas de corps défini => pas de {}
+    //    + Un point-virgule en fin de ligne
+    public abstract void uneMethode (liste_de_paramètres);
+    ...
+}
+</code>
-=== Définir la méthode en Abstract ===
+=== Hériter de la classe abstraite (rien de nouveau ...) ===
+<code=java>
+public class Classe_B extends Classe_A {
+    ...
+}
+</code>
-Nous devons transformer la méthode **print** en **Abstract**, cependant, lorsqu'une méthode est de type **Abstract**, elle ne peut contenir de body.
+=== Implémenter les méthodes abstraites ===
+<code=java>
+public class UneClasse extends Classe_A {
-{{bloc2:prog:poo:printab.png}}
+    @Override
+    public void uneMethode (liste_de_paramètres) {
-Il faut donc supprimer ce qu'elle contient.
+        // Implémentation de la méthode ... qui n'est plus abstraite
+    }
-{{bloc2:prog:poo:printabstracted.png}}
+}
+</code>
-Une fois la méthode transformé en **Abstract**, nous pouvons **décommenter** la méthode **print** de CD et DVD.
-Et pour finir nous devons mettre la pastille **Override** pour ne pas avoir de **conflit** entre les méthodes print de la **classe mère** et de ses **classes filles**.
-{{bloc2:prog:poo:override.png}}