Tag 3 Unterricht und Aufgaben

Tag 3/Override/Krokodile/Krokodil.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+
+namespace _10_Override.Krokodile;
+
+public abstract class Krokodil
+{
+    public static readonly List<Krokodil> KrokodilListe = new List<Krokodil>();
+
+    /*
+    // Full-Property mit sichtbarem Backing-Field:
+    private string farbe;
+    
+    public string Farbe
+    {
+        get => farbe; // Expression-Bodied
+
+        private set
+        {
+            farbe = value;
+        }
+    }*/
+
+    public string Farbe { get; private set; } // Property mit unsichtbarem Backing-Field.
+    // Das passende Feld zur Property wird vom Compiler angelegt und wir haben im Code keinen direkten Zugriff darauf.
+
+    // Abstrakte Klassen haben in der Regel 'protected' Konstruktoren.
+    protected Krokodil() : this("Keine Farbe") // Konstruktor-Verkettung mit 'this'.
+    {
+        
+    }
+
+    protected Krokodil(string farbe)
+    {
+        Farbe = farbe;
+        KrokodilListe.Add(this);
+    }
+
+    // Abstrakte Methode:
+    /// <summary>
+    /// Diese Methode gibt Informationen zum Lebensraum des Krokodils aus.
+    /// </summary>
+    public abstract void ZeigeInfoZumLebensraum();
+
+    // 'virtual-Methoden KÖNNEN überschrieben werden. 'abstract'-Methoden MÜSSEN überschrieben werden. Methoden, die nicht abstract oder virtual sind, können NICHT überschrieben werden.
+    public virtual void Schwimmen()
+    {
+        Console.WriteLine("Ich schwimme im Wasser.");
+    }
+}

Tag 3/Override/Krokodile/Leistenkrokodil.cs

@@ -0,0 +1,31 @@
+using System;
+
+namespace _10_Override.Krokodile;
+
+// 'sealed': Entspricht in diesem Kontext dem 'final' aus Java. Die Klasse wird versiegelt und es kann nicht weiter von ihr geerbt werden.
+public sealed class Leistenkrokodil : Krokodil
+{
+    public Leistenkrokodil(string farbe) : base(farbe) 
+    {
+    }
+
+    // Abstrakte Methoden MÜSSEN in nicht-abstrakten Klassen überschrieben werden.
+    // Unterschied zu Java: 'override' ist ein Schlüsselwort, welches wir zum Überschreiben angeben MÜSSEN.
+    public override void ZeigeInfoZumLebensraum()
+    {
+        Console.WriteLine("Ich lebe in Ostindien, Südostasien und komme sogar bis nach Nordaustralien.");
+    }
+
+    // Virtuelle Methoden KÖNNEN überschrieben werden:
+    public override void Schwimmen()
+    {
+        base.Schwimmen(); // Mit 'base' können wir hier das Verhalten der überschriebenen Methode wiederverwenden.
+        Console.WriteLine("Ich schwimme im Salzwasser.");
+    }
+
+    // Diese Methode wird nicht geerbt oder überschrieben. Sie ist nur in dieser Klasse vorhanden.
+    public void ImSchlammLiegen()
+    {
+        Console.WriteLine("Ich liege im Schlamm. Hier mag ich es.");
+    }
+}

Tag 3/Override/Krokodile/Nilkrokodil.cs

@@ -0,0 +1,31 @@
+using System;
+
+namespace _10_Override.Krokodile;
+
+public class Nilkrokodil : Krokodil
+{
+    public Nilkrokodil(string farbe) : base(farbe)
+    {
+    }
+
+    public sealed override void ZeigeInfoZumLebensraum() // 'sealed' kann für Methoden verwendet werden, um weiteres Überschreiben zu verbieten.
+    {
+        Console.WriteLine("Anders als mein Name vermuten lässt, lebe ich nicht nur am Nil, sondern in fast ganz Afrika.");
+    }
+
+    // 'new' kann verwendet werden, um den geerbten Member auszublenden. Dies wird vor allem für Methoden verwendet, die weder virtual noch abstract sind. In C# können nur Methoden überschrieben werden, die die Schlüsselwörter 'virtual', 'abstract' oder 'override' verwenden. 'new' funktioniert auch dort, wo 'override' nicht funktionieren würde.
+    public new void Schwimmen()
+    {
+        base.Schwimmen();
+        Console.WriteLine("Ich schwimme im Süßwasser.");
+    }
+
+    public void ImGrasLiegen()
+    {
+        Console.WriteLine("Ich liege im Gras. Hier mag ich es.");
+    }
+
+    // Wir können in C# nur abstrakte und virtuelle Methoden überschreiben. Um trotzdem das Verhalten einer nicht-abstrakten und nicht-virtuellen Methode verändern zu können, gibt es in C# noch das 'new'-Schlüsselwort.
+    public new string Farbe => base.Farbe.ToUpper(); // Der Getter der Property wurde neu definiert und gibt nun die Farbe in Großbuchstaben zurück.
+    // Diese Schreibweise hier wird "Expression Bodied Member" genannt und funktioniert bei allen Methoden und Properties, die nur 1 Befehl ausführen.
+}