C# Abstract Classes & Methods Onder de Loep

Verken C# abstract classes en methodes door duidelijke voorbeelden, inheritance patronen, constructors en real-world use cases.

Abstract Class

In C# dienen abstract classes als templates die niet direct geïnstantieerd kunnen worden. Het abstract keyword signaleert dat een klasse bedoeld is om gesubclasseerd te worden. Bijvoorbeeld:

// Abstract klasse definiëren
abstract class Language {
    // Velden en methodes
}
// Poging tot instantie creatie geeft fout
// Language obj = new Language();

Een abstract klasse kan zowel abstract methodes (declaraties zonder body) als concrete methodes (volledig geïmplementeerd) bevatten. Bijvoorbeeld:

abstract class Language {
    // Abstract methode – geen body
    public abstract void Display();
    // Concrete methode – heeft implementatie
    public void DisplayInfo() {
        Console.WriteLine("Concrete methode in abstract klasse");
    }
}

Voordat u verdergaat, zorg dat u comfortabel bent met C# inheritance concepten.

Een Abstract Klasse Erven

Omdat u een abstract klasse niet direct kunt instantiëren, moet u een concrete subklasse aanmaken die ervan afstamt. De subklasse erft de abstract klasse's leden, wat u in staat stelt ze te gebruiken via het derived object. Voorbeeld:

using System;
namespace AbstractClassDemo {
    abstract class Language {
        public void Display() {
            Console.WriteLine("Concrete methode in abstract klasse");
        }
    }
    // Concrete subklasse
    class Program : Language {
        static void Main(string[] args) {
            Program prog = new Program();
            prog.Display();
            Console.ReadLine();
        }
    }
}

Output

Concrete methode in abstract klasse

In dit voorbeeld is Language abstract, terwijl Program erft en Display() kan aanroepen. Let op dat abstract classes niet sealed kunnen zijn; ze moeten altijd als base types dienen.

Let op: Gebruik dit patroon wanneer u een gemeenschappelijk contract nodig hebt dat meerdere derived types zullen implementeren.

Abstract Methodes in C#

Een abstract methode declareert een handtekening zonder body. Het verplicht derived, non-abstract klassen om een implementatie te leveren. Bijvoorbeeld:

public abstract void Display();

Alleen abstract klassen kunnen abstract methodes bevatten. Wanneer een concrete subklasse zo'n klasse erft, moet het elke abstract member overriden tenzij het zichzelf ook abstract declareert.

Voorbeeld: Een Abstract Methode Implementeren

using System;
namespace AbstractClassDemo {
    abstract class Animal {
        public abstract void MakeSound();
    }
    class Dog : Animal {
        public override void MakeSound() {
            Console.WriteLine("Blaf Blaf");
        }
    }
    class Program {
        static void Main(string[] args) {
            Dog dog = new Dog();
            dog.MakeSound();
            Console.ReadLine();
        }
    }
}

Output

Blaf Blaf

Hier declareert Animal een abstract methode MakeSound(). De concrete subklasse Dog levert de override, wat het contract vervult.

Let op: Abstract methodes zijn impliciet virtual; daarom is het virtual keyword onnodig en niet toegestaan.

Abstract Properties met Getters en Setters

Abstract accessors staan derived klassen toe custom logica te leveren voor property get en set operaties. Voorbeeld:

using System;
namespace AbstractClassDemo {
    abstract class Animal {
        protected string name;
        public abstract string Name { get; set; }
    }
    class Dog : Animal {
        public override string Name {
            get { return name; }
            set { name = value; }
        }
    }
    class Program {
        static void Main(string[] args) {
            Dog dog = new Dog();
            dog.Name = "Tom";
            Console.WriteLine("Naam: " + dog.Name);
            Console.ReadLine();
        }
    }
}

Output

Naam: Tom

De derived klasse implementeert de abstract property, wat geencapsuleerde state management mogelijk maakt.

Constructors in Abstract Classes

Abstract klassen kunnen constructors definiëren om gedeelde state voor alle subklassen te initialiseren. Wanneer een subklasse instantie wordt aangemaakt, voert de abstract klasse constructor eerst uit. Voorbeeld:

using System;
namespace AbstractClassDemo {
    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) {
            Dog d1 = new Dog();
            Console.ReadLine();
        }
    }
}

Output

Animal Constructor
Dog Constructor

Subklassen kunnen ook destructors definiëren als cleanup logica nodig is.

Let op: Constructors zijn nuttig voor het opzetten van gemeenschappelijke resources die alle derived types nodig hebben.

C# Abstractie Door Abstract Classes

Abstract klassen bieden een mechanisme voor abstractie: ze verbergen implementatiedetails terwijl ze een schone interface blootleggen. Dit vereenvoudigt complexe systemen door te focussen op "wat" in plaats van "hoe".

Overweeg een real-world analogie: remsystemen op motorfietsen. Het externe gedrag van de rem — vertragen of stoppen van de fiets — is consistent, maar het onderliggende mechanisme varieert tussen modellen. Abstract klassen laten elk model zijn unieke remlogica implementeren zonder het externe contract te veranderen.

Voorbeeld: Motorfiets Remmen

using System;
namespace AbstractClassDemo {
    abstract class MotorBike {
        public abstract void Brake();
    }
    class SportsBike : MotorBike {
        public override void Brake() {
            Console.WriteLine("Sports Bike Brake");
        }
    }
    class MountainBike : MotorBike {
        public override void Brake() {
            Console.WriteLine("Mountain Bike Brake");
        }
    }
    class Program {
        static void Main(string[] args) {
            SportsBike s1 = new SportsBike();
            s1.Brake();
            MountainBike m1 = new MountainBike();
            m1.Brake();
            Console.ReadLine();
        }
    }
}

Output

Sports Bike Brake
Mountain Bike Brake

Hier declareert MotorBike een abstract methode Brake(). Elke concrete fiets klasse levert zijn specifieke implementatie, wat polymorfisme demonstreert.

Let op: Voor volledige abstractie — geen base implementatie helemaal — overweeg interfaces te gebruiken.