Section courante

A propos

Section administrative du site

Les classes abstraites

Les classes abstraites sont des classes et des méthodes de types abstraites. Ainsi, pendant la conception hiérarchique, on pourra créer des classes généralistes et transférer l'intégration à des niveaux plus éloignés quand le comportement arrive à niveau plus défini. Par exemple, si aurait a définir de mathématique, on serait à niveau trop vague pour parler de géométrie et encore plus vague pour calculer la largeur d'un objet. En plus, nous n'avons pas d'unité de mesure à lequel se référé à se niveau. Donc, on ne peut pas le déterminer une réponse n'étant pas abstraite à se niveau de classe, on utilisera donc le mot réservé «abstract». Dans un deuxième exemple, si nous avons des véhicules, il est difficile d'indiquer la consommation d'essence sans savoir la marque, si un modèle est VUS ou une décapotable. On commencera donc en indiquant une classe abstraite Vehicule, lequel sera remplacé par une classe précise de fabricant et de modèle.

abstract class nomclasse {
   definition;
}

Exemples

Voici un exemple d'une classe abstraite en C# basée sur un concept de véhicules, avec un focus particulier sur les VUS (Véhicules Utilitaires Sport) :

  1. using System;
  2.  
  3. namespace AbstractClassVehicles {
  4.     // Classe abstraite représentant un véhicule
  5.     public abstract class Vehicle {
  6.         // Propriétés communes à tous les véhicules
  7.         public string Make { get; set; } // Marque
  8.         public string Model { get; set; } // Modèle
  9.         public int Year { get; set; } // Année de fabrication
  10.  
  11.         // Constructeur pour initialiser les propriétés
  12.         protected Vehicle(string make, string model, int year) {
  13.             Make = make;
  14.             Model = model;
  15.             Year = year;
  16.         }
  17.  
  18.         // Méthode abstraite que les sous-classes doivent implémenter
  19.         public abstract void DisplayInfo();
  20.  
  21.         // Méthode concrète pour démarrer le véhicule
  22.         public virtual void Start() {
  23.             Console.WriteLine($"{Make} {Model} démarre.");
  24.         }
  25.     }
  26.  
  27.     // Classe abstraite spécifique aux VUS (hérite de Vehicle)
  28.     public abstract class SUV : Vehicle {
  29.         public bool HasFourWheelDrive { get; set; } // Indique si le VUS a 4 roues motrices
  30.  
  31.         protected SUV(string make, string model, int year, bool hasFourWheelDrive) : base(make, model, year) {
  32.             HasFourWheelDrive = hasFourWheelDrive;
  33.         }
  34.  
  35.         // Méthode concrète spécifique aux VUS
  36.         public void ToggleFourWheelDrive() {
  37.             if(HasFourWheelDrive) {
  38.                 Console.WriteLine($"{Make} {Model} active les 4 roues motrices.");
  39.             } else {
  40.                 Console.WriteLine($"{Make} {Model} n'a pas de 4 roues motrices.");
  41.             }
  42.         }
  43.     }
  44. }

Voici un exemple d'une classe abstraite utilisé par d'autres classes en C# :

  1. using System;
  2.  
  3. namespace AbstractClassExample
  4. {
  5.     // Définition d'une classe abstraite
  6.     public abstract class Shape {
  7.         // Propriété commune à toutes les formes
  8.         public string Color { get; set; }
  9.  
  10.         // Constructeur de la classe abstraite
  11.         public Shape(string color) {
  12.             Color = color;
  13.         }
  14.  
  15.         // Méthode abstraite : doit être implémentée par les classes dérivées
  16.         public abstract double GetArea();
  17.  
  18.         // Méthode concrète : peut être utilisée ou remplacée par les classes dérivées
  19.         public virtual void DisplayInfo() {
  20.             Console.WriteLine($"Forme de couleur : {Color}");
  21.         }
  22.     }
  23.  
  24.     // Classe concrète héritant de Shape
  25.     public class Circle : Shape {
  26.         public double Radius { get; set; }
  27.  
  28.         public Circle(string color, double radius) : base(color) {
  29.             Radius = radius;
  30.         }
  31.  
  32.         public override double GetArea() {
  33.             return Math.PI * Radius * Radius;
  34.         }
  35.  
  36.         public override void DisplayInfo() {
  37.             base.DisplayInfo();
  38.             Console.WriteLine($"Cercle avec un rayon de {Radius}, Surface : {GetArea():0.00}");
  39.         }
  40.     }
  41.  
  42.     // Une autre classe concrète héritant de Shape
  43.     public class Rectangle : Shape {
  44.         public double Width { get; set; }
  45.         public double Height { get; set; }
  46.  
  47.         public Rectangle(string color, double width, double height) : base(color) {
  48.             Width = width;
  49.             Height = height;
  50.         }
  51.  
  52.         public override double GetArea() {
  53.             return Width * Height;
  54.         }
  55.  
  56.         public override void DisplayInfo() {
  57.             base.DisplayInfo();
  58.             Console.WriteLine($"Rectangle de {Width} x {Height}, Surface : {GetArea():0.00}");
  59.         }
  60.     }
  61.  
  62.     class Program {
  63.         static void Main(string[] args) {
  64.             Shape circle = new Circle("Rouge", 5.5);
  65.             circle.DisplayInfo();
  66.  
  67.             Shape rectangle = new Rectangle("Bleu", 10, 4);
  68.             rectangle.DisplayInfo();
  69.         }
  70.     }
  71. }

Dernière mise à jour : Dimanche, le 17 août 2014