C# abstracte klasse en methode

In deze zelfstudie leren we over de abstracte klasse en methode van C# met behulp van voorbeelden.

Abstracte klasse

In C# kunnen we geen objecten van een abstracte klasse maken. We gebruiken de abstract trefwoord om een ​​abstracte klasse te maken. Bijvoorbeeld,

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

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

Een abstracte klasse kan zowel abstracte methoden (methode zonder body) als niet-abstracte methoden (methode met body) hebben. Bijvoorbeeld,

abstract class Language {

  // abstract method
  public abstract void display1();

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

Zorg ervoor dat u op de hoogte bent van C#-overerving voordat u verder gaat.

Abstracte klasse overerven

Omdat we geen objecten van een abstracte klasse kunnen maken, moeten we er een afgeleide klasse van maken. Zodat we toegang hebben tot leden van de abstracte klasse met behulp van het object van de afgeleide klasse. Bijvoorbeeld,

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();
    }
  }
}

Uitvoer

Non abstract method

In het bovenstaande voorbeeld hebben we een abstracte klasse gemaakt met de naam Taal . De klasse bevat een niet-abstracte methode display() .

We hebben het Programma gemaakt klasse die de abstracte klasse erft. Let op de verklaring,

obj.display();

Hier, obj is het object van de afgeleide klasse Programma . We roepen de methode van de abstracte klasse aan met het object obj .

Opmerking :We kunnen abstracte klasse alleen als basisklasse gebruiken. Dit is de reden waarom abstracte klassen niet kunnen worden verzegeld. Ga voor meer informatie naar C# verzegelde klasse en methode.

C# abstracte methode

Een methode die geen body heeft, staat bekend als een abstracte methode. We gebruiken de abstract trefwoord om abstracte methoden te maken. Bijvoorbeeld,

public abstract void display();

Hier, display() is een abstracte methode. Een abstracte methode kan alleen aanwezig zijn in een abstracte klasse.

Wanneer een niet-abstracte klasse een abstracte klasse erft, moet deze een implementatie van de abstracte methoden bieden.

Voorbeeld:implementatie van de abstracte methode

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(); 
    }
  }
}

Uitvoer

Bark Bark 

In het bovenstaande voorbeeld hebben we een abstracte klasse gemaakt met de naam Animal . We hebben een abstracte methode makeSound() in de klas.

We hebben een Hond klasse die erft van de Animal klas. Hond class biedt de implementatie van de abstracte methode makeSound() .

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

  Console.WriteLine("Bark Bark");

}

Let op, we hebben override . gebruikt met de makeSound() methode. Dit geeft aan dat de methode de methode van de basisklasse overschrijft.

We gebruikten toen het object van de Hond class om toegang te krijgen tot makeSound() .

Als de Hond class had niet voorzien in de implementatie van de abstracte methode makeSound() , Hond klasse had ook als abstract gemarkeerd moeten zijn.

Opmerking :In tegenstelling tot de C#-overerving kunnen we virtual . niet gebruiken met de abstracte methoden van de basisklasse. Dit komt omdat een abstracte klasse impliciet virtueel is.

Abstracte klasse met get en set-accessors

We kunnen get en set-accessors markeren als abstract. Bijvoorbeeld,

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();
    }
  }
}

Uitvoer

Name: Tom

In het bovenstaande voorbeeld hebben we de get en set-accessor gemarkeerd als abstract.

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

We zijn bezig met het instellen en verkrijgen van de waarde van de naam veld van de abstracte klasse Animal met behulp van het object van de afgeleide klasse Hond .

Toegang tot constructor van abstracte klassen

Een abstracte klasse kan ook constructors hebben. Bijvoorbeeld,

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();
    }
  }
}

Uitvoer

Animal Constructor
Dog Constructor

In het bovenstaande voorbeeld hebben we een constructor gemaakt binnen de abstracte klasse Animal .

Dog d1 = new Dog();

Hier, wanneer we een object maken van de afgeleide klasse Hond de constructor van de abstracte klasse Animal wordt ook gebeld.

Opmerking :We kunnen ook destructors gebruiken binnen de abstracte klasse.

C#-abstractie

De abstracte klassen worden gebruikt om abstractie te bereiken in C#.

Abstractie is een van de belangrijke concepten van objectgeoriënteerd programmeren. Het stelt ons in staat om onnodige details te verbergen en alleen de benodigde informatie te tonen.

Dit helpt ons om complexiteit te beheren door details te verbergen met een eenvoudiger idee op een hoger niveau.

Een praktisch voorbeeld van abstractie kunnen motorremmen zijn. We weten wat een rem doet. Als we op de rem trappen, stopt de motor. De werking van de rem wordt echter voor ons verborgen gehouden.

Het grote voordeel van het verbergen van de werking van de rem is dat de fabrikant de remmen nu voor verschillende motorfietsen anders kan implementeren. Wat de rem doet, is echter hetzelfde.

Voorbeeld:C#-abstractie

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();
    }
  }
}

Uitvoer

Sports Bike Brake
Mountain Bike Brake

In het bovenstaande voorbeeld hebben we een abstracte klasse MotorBike . gemaakt . Het heeft een abstracte methode brake() .

Als rem() is een abstracte methode voor de implementatie van brake() in Motorfiets wordt verborgen gehouden.

Elke motor heeft een andere uitvoering van de rem. Dit is waarom SportsBike maakt zijn eigen implementatie van brak() en MountainBike maakt zijn eigen implementatie van brak() .

Opmerking :We gebruiken interfaces om volledige abstractie in C# te bereiken. Ga voor meer informatie naar de C#-interface.