Différences

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

--- bloc2:prog:poo:classesabstraites [2023/03/29 14:58] – supprimée - modification externe (Unknown date) 127.0.0.1
+++ bloc2:prog:poo:classesabstraites [2023/04/11 12:00] (Version actuelle) – [Concept] admin
@@ Ligne 1: / Ligne 1: @@
+====== Classes abtraites ======
+===== Concept =====
+Une **classe abstraite** est une classe qui ne peut pas être instanciée directement, mais qui sert plutôt de **modèle** ou de **base** pour d'autres classes. Elle est conçue pour **être héritée** et **étendue** par d'autres classes qui peuvent en revanche être instanciées.
+Dans une classe abstraite, on pourra trouver :
+  * Des **méthodes et attributs classiques**, comme on en a déjà l’habitude en POO ;
+  * Des **méthodes dites « abstraites »** qui fournissent uniquement leur **signature**. Charge aux classes qui en héritent de définir le code de ces méthodes.
+Exemple :
+<code java A.java>
+// une classe abstraite A
+public abstract class A
+{
+    // une méthode non abstraite (=implémentée) dans A
+    public void maMethode() {
+        ...
+    }
+    // une méthode abstraite de A
+    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.
+  * 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.
+===== Exemples d'utilisation =====
+=== Définir une classe abstraite ===
+<code=java>
+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>
+=== Hériter de la classe abstraite (rien de nouveau ...) ===
+<code=java>
+public class Classe_B extends Classe_A {
+    ...
+}
+</code>
+=== Implémenter les méthodes abstraites ===
+<code=java>
+public class UneClasse extends Classe_A {
+    @Override
+    public void uneMethode (liste_de_paramètres) {
+        // Implémentation de la méthode ... qui n'est plus abstraite
+    }
+}
+</code>