C# Abstrakte Klassen & Methoden meistern: Praktischer Leitfaden

C# Abstrakte Klassen & Methoden meistern

Erkunden Sie C# abstrakte Klassen und Methoden durch klare Beispiele, Vererbungsmuster, Konstruktoren und reale Anwendungsfälle.

Abstrakte Klasse

In C# dienen abstrakte Klassen als Vorlagen, die nicht direkt instanziiert werden können. Das abstract Schlüsselwort signalisiert, dass eine Klasse zum Unterklassen gedacht ist. Beispiel:

// Abstrakte Klasse definieren
abstract class Language {
    // Felder und Methoden
}
// Versuch, Instanz zu erstellen, wirft Fehler
// Language obj = new Language();

Eine abstrakte Klasse kann sowohl abstrakte Methoden (Deklarationen ohne Körper) als auch konkrete Methoden (voll implementiert) enthalten. Zum Beispiel:

abstract class Language {
    // Abstrakte Methode – kein Körper
    public abstract void Display();
    // Konkrete Methode – hat Implementierung
    public void DisplayInfo() {
        Console.WriteLine("Concrete method in abstract class");
    }
}

Stellen Sie vor dem Fortfahren sicher, dass Sie mit C# Vererbungskonzepten vertraut sind.

---

Abstrakte Klasse erben

Da Sie eine abstrakte Klasse nicht direkt instanziieren können, müssen Sie eine konkrete Unterklasse erstellen, die von ihr ableitet. Die Unterklasse erbt die Member der abstrakten Klasse, sodass Sie diese über das abgeleitete Objekt nutzen können. Beispiel:

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

Ausgabe

Concrete method in abstract class

In diesem Beispiel ist Language abstrakt, während Program davon erbt und Display() aufrufen kann. Beachten Sie, dass abstrakte Klassen nicht sealed sein können; sie müssen immer als Basistypen dienen.

Hinweis: Nutzen Sie dieses Muster, wenn Sie einen gemeinsamen Vertrag benötigen, den mehrere abgeleitete Typen implementieren.

---

Abstrakte Methoden in C#

Eine abstrakte Methode deklariert eine Signatur ohne Körper. Sie verpflichtet abgeleitete, nicht-abstrakte Klassen, eine Implementierung bereitzustellen. Beispiel:

public abstract void Display();

Nur abstrakte Klassen können abstrakte Methoden enthalten. Wenn eine konkrete Unterklasse eine solche Klasse erbt, muss sie jeden abstrakten Member überschreiben, es sei denn, sie erklärt sich selbst als abstrakt.

Beispiel: Abstrakte Methode implementieren

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

Ausgabe

Bark Bark

Hier deklariert Animal eine abstrakte Methode MakeSound(). Die konkrete Unterklasse Dog liefert den Override und erfüllt den Vertrag.

Hinweis: Abstrakte Methoden sind implizit virtual; daher ist das virtual Schlüsselwort unnötig und nicht erlaubt.

---

Abstrakte Eigenschaften mit Gettern und Settern

Abstrakte Accessoren erlauben abgeleiteten Klassen, benutzerdefinierte Logik für Property-Get und -Set Operationen bereitzustellen. Beispiel:

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("Name: " + dog.Name);
            Console.ReadLine();
        }
    }
}

Ausgabe

Name: Tom

Die abgeleitete Klasse implementiert die abstrakte Eigenschaft und ermöglicht gekapselte Zustandsverwaltung.

---

Konstruktoren in abstrakten Klassen

Abstrakte Klassen können Konstruktoren definieren, um gemeinsamen Zustand für alle Unterklassen zu initialisieren. Beim Erstellen einer Unterklasseninstanz wird der abstrakte Klassenkonstruktor zuerst ausgeführt. Beispiel:

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

Ausgabe

Animal Constructor Dog Constructor

Unterklassen können auch Destruktoren definieren, falls Bereinigungslogik nötig ist.

Hinweis: Konstruktoren sind nützlich, um gemeinsame Ressourcen einzurichten, die alle abgeleiteten Typen benötigen.

---

C# Abstraktion durch abstrakte Klassen

Abstrakte Klassen bieten einen Mechanismus für Abstraktion: Sie verbergen Implementierungsdetails und stellen eine saubere Schnittstelle bereit. Dies vereinfacht komplexe Systeme, indem der Fokus auf „Was“ statt „Wie“ liegt.

Betrachten Sie eine reale Analogie: Bremssysteme bei Motorrädern. Das externe Verhalten der Bremse – Verlangsamen oder Anhalten – ist konsistent, aber der zugrunde liegende Mechanismus variiert zwischen Modellen. Abstrakte Klassen lassen jedes Modell seine einzigartige Bremslogik implementieren, ohne den externen Vertrag zu ändern.

Beispiel: Motorradbremsen

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

Ausgabe

Sports Bike Brake Mountain Bike Brake

Hier deklariert MotorBike eine abstrakte Methode Brake(). Jede konkrete Fahrradklasse liefert ihre spezifische Implementierung, was Polymorphie demonstriert.

Hinweis: Für vollständige Abstraktion – gar keine Basimplementierung – ziehen Sie Interfaces in Betracht.