Classe abstraite et méthode C#

Dans ce didacticiel, nous allons découvrir la classe et la méthode abstraites C# à l'aide d'exemples.

Classe abstraite

En C #, nous ne pouvons pas créer d'objets d'une classe abstraite. Nous utilisons le abstract mot-clé pour créer une classe abstraite. Par exemple,

// create an abstract class
abstract class Language {
  // fields and methods
}
...

// try to create an object Language
// throws an error
Language obj = new Language();

Une classe abstraite peut avoir à la fois des méthodes abstraites (méthode sans corps) et des méthodes non abstraites (méthode avec corps). Par exemple,

abstract class Language {

  // abstract method
  public abstract void display1();

  // non-abstract method
  public void display2() {
    Console.WriteLine("Non abstract method");
  }
}

Avant d'aller de l'avant, assurez-vous de connaître l'héritage C#.

Hériter de la classe abstraite

Comme nous ne pouvons pas créer d'objets d'une classe abstraite, nous devons en créer une classe dérivée. Pour que nous puissions accéder aux membres de la classe abstraite en utilisant l'objet de la classe dérivée. Par exemple,

using System;
namespace AbstractClass {

  abstract class Language {

    // non-abstract method
    public void display() {
      Console.WriteLine("Non abstract method");
    }
  }

  // inheriting from abstract class
  class Program : Language {

    static void Main (string [] args) {
      
      // object of Program class
      Program obj = new Program();

      // access method of an abstract class
      obj.display();

      Console.ReadLine();
    }
  }
}

Sortie

Non abstract method

Dans l'exemple ci-dessus, nous avons créé une classe abstraite nommée Language . La classe contient une méthode non abstraite display() .

Nous avons créé le Programme classe qui hérite de la classe abstraite. Remarquez la déclaration,

obj.display();

Ici, obj est l'objet de la classe dérivée Program . Nous appelons la méthode de la classe abstraite en utilisant l'objet obj .

Remarque :Nous ne pouvons utiliser la classe abstraite que comme classe de base. C'est pourquoi les classes abstraites ne peuvent pas être scellées. Pour en savoir plus, consultez Classe et méthode scellées C#.

Méthode abstraite C#

Une méthode qui n'a pas de corps est appelée méthode abstraite. Nous utilisons le abstract mot-clé pour créer des méthodes abstraites. Par exemple,

public abstract void display();

Ici, display() est une méthode abstraite. Une méthode abstraite ne peut être présente qu'à l'intérieur d'une classe abstraite.

Lorsqu'une classe non abstraite hérite d'une classe abstraite, elle doit fournir une implémentation des méthodes abstraites.

Exemple :Implémentation de la méthode abstraite

using System;
namespace AbstractClass {

  abstract class Animal {

    // abstract method
    public abstract void makeSound();
  }

  // inheriting from abstract class
  class Dog : Animal {

    // provide implementation of abstract method
    public override void makeSound() {

      Console.WriteLine("Bark Bark");

    }
  }
  class Program  {
    static void Main (string [] args) {
      // create an object of Dog class
      Dog obj = new Dog();
      obj.makeSound();    

      Console.ReadLine(); 
    }
  }
}

Sortie

Bark Bark

Dans l'exemple ci-dessus, nous avons créé une classe abstraite nommée Animal . Nous avons une méthode abstraite makeSound() à l'intérieur de la classe.

Nous avons un chien classe qui hérite de la classe Animal classer. Chien La classe fournit l'implémentation de la méthode abstraite makeSound() .

// provide implementation of abstract method
public override void makeSound() {

  Console.WriteLine("Bark Bark");

}

Remarquez, nous avons utilisé override avec le makeSound() méthode. Cela indique que la méthode remplace la méthode de la classe de base.

Nous avons ensuite utilisé l'objet du Chien classe pour accéder à makeSound() .

Si le chien la classe n'avait pas fourni l'implémentation de la méthode abstraite makeSound() , Chien la classe aurait également dû être marquée abstraite.

Remarque :Contrairement à l'héritage C#, nous ne pouvons pas utiliser virtual avec les méthodes abstraites de la classe de base. C'est parce qu'une classe abstraite est implicitement virtuelle.

Classe abstraite avec accesseurs get et set

Nous pouvons marquer les accesseurs get et set comme abstraits. Par exemple,

using System;
namespace AbstractClass {
  abstract class Animal {
    
    protected string name;
    // abstract method
    public abstract string Name {
      get;
      set;
    }
  }

  // inheriting from abstract class
  class Dog : Animal {

    // provide implementation of abstract method
    public override string Name {
      get {
        return name;
      }
      set {
        name = value; 
      }
    }
   
  }
  class Program  {
    static void Main (string [] args) {
      // create an object of Dog class
      Dog obj = new Dog();  
      obj.Name = "Tom";
      Console.WriteLine("Name: " + obj.Name); 

      Console.ReadLine();
    }
  }
}

Sortie

Name: Tom

Dans l'exemple ci-dessus, nous avons marqué l'accesseur get et set comme abstrait.

obj.Name = "Tom";
Console.WriteLine("Name: " + obj.Name);

Nous définissons et obtenons la valeur du nom champ de la classe abstraite Animal en utilisant l'objet de la classe dérivée Dog .

Accéder au constructeur de classes abstraites

Une classe abstraite peut également avoir des constructeurs. Par exemple,

using System;
namespace AbstractClass {
  abstract class Animal {
    
    public Animal() {
      Console.WriteLine("Animal Constructor");
    }
  }

  class Dog : Animal {
    public Dog() {
      Console.WriteLine("Dog Constructor");
    }   
  }

  class Program  {
    static void Main (string [] args) {
      // create an object of Dog class
      Dog d1 = new Dog();  

      Console.ReadLine();
    }
  }
}

Sortie

Animal Constructor
Dog Constructor

Dans l'exemple ci-dessus, nous avons créé un constructeur dans la classe abstraite Animal .

Dog d1 = new Dog();

Ici, lorsque nous créons un objet de la classe dérivée Chien le constructeur de la classe abstraite Animal est également appelé.

Remarque :Nous pouvons également utiliser des destructeurs à l'intérieur de la classe abstraite.

Abstraction C#

Les classes abstraites sont utilisées pour réaliser l'abstraction en C#.

L'abstraction est l'un des concepts importants de la programmation orientée objet. Cela nous permet de masquer les détails inutiles et de n'afficher que les informations nécessaires.

Cela nous aide à gérer la complexité en masquant les détails avec une idée plus simple et de niveau supérieur.

Un exemple pratique d'abstraction peut être les freins de moto. Nous savons ce que fait un frein. Lorsque nous appliquons le frein, la moto s'arrête. Cependant, le fonctionnement du frein nous est caché.

Le principal avantage de masquer le fonctionnement du frein est que le fabricant peut désormais implémenter les freins différemment pour différentes motos. Cependant, ce que fait le frein sera le même.

Exemple :abstraction C#

using System;
namespace AbstractClass {
  abstract class MotorBike {
    
    public abstract void brake();
  }

  class SportsBike : MotorBike {

    // provide implementation of abstract method
    public override void brake() {
      Console.WriteLine("Sports Bike Brake");
    }
   
  }

  class MountainBike : MotorBike {

    // provide implementation of abstract method
    public override void brake() {      
      Console.WriteLine("Mountain Bike Brake");
    }
   
  }
  class Program  {
    static void Main (string [] args) {
      // create an object of SportsBike class
      SportsBike s1 = new SportsBike();  
      s1.brake();

      // create an object of MountainBike class
      MountainBike m1 = new MountainBike();
      m1.brake();

      Console.ReadLine();
    }
  }
}

Sortie

Sports Bike Brake
Mountain Bike Brake

Dans l'exemple ci-dessus, nous avons créé une classe abstraite MotorBike . Il a une méthode abstraite brake() .

Comme frein() est une méthode abstraite l'implémentation de brake() en moto est caché.

Chaque moto a une implémentation différente du frein. C'est pourquoi SportsBike crée sa propre implémentation de brake() et MountainBike crée sa propre implémentation de brake() .

Remarque :Nous utilisons des interfaces pour réaliser une abstraction complète en C#. Pour en savoir plus, visitez l'interface C#.

Héritage C# Classe imbriquée C#

Langue C