• Abstrakte Klassen lassen sich nicht direkt instanziieren.
• Abstrakte Klassen können sowohl abstrakte als auch nicht-abstrakte Methoden, Funktionen und Attribute umfassen.
• Ermöglicht die Wiederverwendung von Quellcode.
• Dient als Basis für abgeleitete Klassen.
• Abstrakte Klassen dienen dazu, die Implementierung spezifischer Methoden, Funktionen und Attribute in abgeleiteten Klassen verbindlich vorzuschreiben.
• Abstrakte Klassen ermöglichen eine klare Struktur im Code, indem sie die direkte Instanziierung verhindern.
• Methoden, Funktionen und Attribute der abstrakten Klasse werden in den abgeleiteten Klassen gemeinsam genutzt, was die Wartbarkeit und Struktur des Codes erheblich vereinfacht.

Im ersten Teil der Grundlagen Verebung haben wir ein Beispielprojekt erstellt, das als abstrakte Klasse die Attribute, Methoden und Funktionen eines Fahrzeugs bereitstellt. Abgeleitete (Childs) sind „Auto“, „Motorrad“ und „LKW“. In diesem Beispielprojekt wird kurz erläutert, wie Methoden, Funktionen oder Attribute überladen werden können, wie etwa im Beispiel des Motorrads, das nicht rück fahren kann und bei dem die Methode „FahrenRueckwaerts“ überladen wurde. Sowie die Möglichkeit, je nach Fahrzeugtyp zusätzliche Methoden, Funktionen und Attribute hinzuzufügen (zum Beispiel bei einem LKW Kippen der Fahrerkabine).
Wer aufrichtig liest wird am Punkt 2 hängen geblieben sein „Abstrakte Klassen können sowohl abstrakte als auch nicht-abstrakte Methoden, Funktionen und Attribute umfassen“. Im Beispielcode sind in der Abstrakten Klasse „Fahrzeug“ nur nicht-abstrakte Methoden und Attribute verwendet worden. Was sind abstrakte Methoden?

Abstrakte Methoden (auch Funktionen und Attribute)

• Abstrakte Methoden werden nicht in der Basisklasse implementiert, nur die Methodensignatur ist vorhanden.
• Abstrakte Methoden müssen mittels Schlüsselwort override in der abgeleiteten Klasse (Child) überschrieben werden.
• Abstrakte Methoden können nur in abstrakte Klassen enthalten sein.
• Abstrakte Methoden müssen in der abgeleiteten Klasse (Child) implementiert werden.

In diesem Teil der Vererbung, werden wir die Klasse Fahrzeug um eine Funktion erweitern. Tanken! Jedes Fahrzeug benötigt Energie, egal ob Wasserstoff, Benzin/Diesel, oder geladen werden muss. Jeder dieser Vorgänge dauert seine Zeit und wird etwas anders ausgeführt und ist nicht bei jedem Fahrzeug gleich. Daher verwende ich mal die Funktion Tanken als Beispiel für abstrakte Funktionen.
Zuerst wird in der Abstrakte Klasse die Methoden Signatur festgelegt:

/// <summary>
/// Tanken
/// </summary>
/// <returns>Bei Erfolg true</returns>
/// <remarks>
/// Fahrzeuge müssen Tanken.
/// Ob Fossil oder regenerative Stoffe, ob Aufladen oder Wasserstoff, etc.
/// Bei abstrakten Methoden, Funktionen oder Attributen wird kein Code hinterlegt, lediglich die Signatur
/// </remarks>
public abstract bool Tanken();

Ab sofort ist es obligatorisch, die Funktion Tanken in allen abgeleiteten Klassen zu implementieren. Dadurch kann ich als Programmierer sicherstellen, dass bei neuen Fahrzeugen der oder die nächste Mitarbeiter:in die Funktion Tanken korrekt in neues Fahrzeug integriert.
Änderungen in den aktuellen abgeleiteten Klassen (als Beispiel nur die Änderung in der Klasse Auto) :

/// <summary>
/// Auto tanken
/// </summary>
/// <returns>Bei Erfolg true</returns>
public override bool Tanken()
{
    Console.WriteLine("Auto links neben der Tanksäule parken.");
    Console.WriteLine("Fahrer steigt aus.");
    Console.WriteLine("Fahrer öffnet Tankdeckel.");
    Console.WriteLine("Wagen wird mit Benzin getankt");
    Console.WriteLine("Fahrer schließt Tankdeckel.");
    Console.WriteLine("Fahrer bezahlt.");
    return true;
}

Eine Funktion Tanken muss nun in jeder abgeleiteten Klasse von „Fahrzeug“ implementiert werden.
Download bearbeiteter Code (Visual Studio).

Der Vorteil abstrakter Methoden besteht darin, dass sie eine klare Architektur erzwingen, während die einzelnen abgeleiteten Objekte die Methode entsprechend ihren Bedürfnissen implementieren können. Da die Methoden und Funktionen an die Anforderungen der Objekte angepasst sind, erfolgt auch die Wartung der Methoden und Funktionen innerhalb der abgeleiteten Klassen.

Der Beitrag Grundlagen Vererbung: Abstrakte Klassen erschien zuerst auf Gernardt.net.

Variablen sind wie Container, die Daten speichern. Sie haben einen Namen und können während der Laufzeit des Programms geändert werden.

• In Programmiersprachen werden Wertebereiche und darauf definierte Operationen zu Datentypen zusammengefasst.
• Elementare Datentypen, sind Standarddatentypen (also in allen Sprachen verfügbar) sind Ganzzahlen, Kommazahlen, Zeichenketten und boolesche Werte.
• Es gibt auch zusammengesetzte Datentypen wie benutzerdefinierte Klassen, Arrays und Listen.

Dabei ist zu bedenken das wir zwischen Werttypen und Verweistypen unterscheiden.

Verweistypen

Verweistypen sind eine Art von Datentypen in Programmiersprachen wie C#, die Verweise auf Daten speichern, anstatt die Daten selbst zu enthalten. Hier sind einige wichtige Punkte zu Verweistypen:

• Variablen von Verweistypen speichern die Verweise auf Ihre Daten (z.B. Objekte).
• Beispiele für Verweistypen sind Strings, Array (auch wenn die einzelnen Elemente Werttypen sind), Klassentypen und Delegaten.
• Verweistypen können den Wert „null“(ohne „“) annehmen

Verweistypen sind z.B. Strings, Objekte, interface, delegate oder record.

Objekte können Array, Auflistungen oder Klasseninstanzen sein. So enthält z.B. eine Variable eines Klassenobjektes ein Verweis auf der Adresse des Objektes im verwalteten Heap. Dadurch sind Verweistypen besonders nützlich wenn es darum geht. komplexe Datenstrukturen zu erstellen und manipulieren.

Werttypen

• Variablen von Werttypen enthalten Ihre Werte direkt.
• Beispiele von Werttypen sind numerische Datentypen, Boolean, Char, Date, Strukturen (auch wenn ihre Member Verweistypen sind) sowie Enumerationen.

Ich nenne hier mal einige Datentypen (Werttypen) der Programmiersprache C#:

Der Beitrag Datentypen erschien zuerst auf Gernardt.net.