Différences

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

--- bloc2:prog:poo:classesabstraites [2023/04/04 11:42] – [Concept] admin
+++ bloc2:prog:poo:classesabstraites [2023/04/11 12:00] (Version actuelle) – [Concept] admin
@@ Ligne 12: / Ligne 12: @@
 Exemple :
-<code=java A.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 abstraite en utilisant le mot-clé "abstract" devant la déclaration de classe. ===
+===== Exemples d'utilisation =====
+=== Définir une classe abstraite ===
 <code=java>
-public abstract class MaClasseAbstraite {
+public abstract class Classe_A {
-    // Déclaration de variables et/ou de méthodes abstraites
+    ...
 }
 </code>
+=== Définir des méthodes abstraites ===
-=== Définir des variables et/ou des méthodes abstraites dans la classe abstraite. ===
 <code=java>
-public abstract class MaClasseAbstraite {
+public  class Classe_A {
-    protected int variableAbstraite;
+    // Bien observer ici qu'il s'agit d'une signature de méthode :
+    //    + Pas de corps défini => pas de {}
-    public abstract void methodeAbstraite();
+    //    + Un point-virgule en fin de ligne
+    public abstract void uneMethode (liste_de_paramètres);
+    ...
 }
 </code>
-=== Hériter de la classe abstraite dans une classe concrète en utilisant le mot-clé "extends". ===
+=== Hériter de la classe abstraite (rien de nouveau ...) ===
 <code=java>
-public class MaClasseConcrete extends MaClasseAbstraite {
+public class Classe_B extends Classe_A {
-    // Implémentation des méthodes et des variables de la classe abstraite
+    ...
 }
 </code>
-=== Implémenter les méthodes abstraites dans la classe concrète en utilisant le mot-clé "override". ===
+=== Implémenter les méthodes abstraites ===
 <code=java>
-public class MaClasseConcrete extends MaClasseAbstraite {
+public class UneClasse extends Classe_A {
-    protected int variableAbstraite;
-    public void methodeAbstraite() {
+    @Override
-        // Implémentation de la méthode abstraite
+    public void uneMethode (liste_de_paramètres) {
+        // Implémentation de la méthode ... qui n'est plus abstraite
     }
 }
 </code>
-=== Utiliser la classe concrète pour instancier des objets et appeler les méthodes héritées de la classe abstraite. ===
-<code=java>
-MaClasseConcrete objet = new MaClasseConcrete();
-objet.methodeAbstraite();
-</code>