C# - Polymorphism: A Beginner's Guide

Hallo, angehende Programmierer! Heute tauchen wir in eines der faszinierendsten Konzepte der objektorientierten Programmierung ein: Polymorphie. Lassen Sie sich nicht vom großen Wort abschrecken – bis zum Ende dieses Tutorials werden Sie Polymorphie wie ein Profi einsetzen können!

Was ist Polymorphie?

Bevor wir loslegen, lösen wir diesen schicken Begriff. "Poly" bedeutet viele und "morph" bedeutet Form. Also geht es bei Polymorphie darum, viele Formen zu haben. In der Programmierung ist es die Fähigkeit von Objekten, unterschiedliche Formen anzunehmen und je nach Kontext unterschiedlich zu verhalten.

Stellen Sie sich vor, Sie sind ein Gestaltwandler (wie cool wäre das?). Sie könnten ein Mensch, eine Katze oder sogar ein Drache sein! Genau das ermöglicht Polymorphie unserem Code – er kann je nach Bedarf unterschiedliche Formen annehmen.

In C# gibt es zwei Hauptarten der Polymorphie:

1. Statische Polymorphie (auch bekannt als Kompilierzeit-Polymorphie)
2. Dynamische Polymorphie (auch bekannt als Laufzeit-Polymorphie)

Lassen Sie uns jede dieser beiden Arten im Detail erkunden.

Statische Polymorphie

Statische Polymorphie tritt auf, wenn der Compiler weiß, welche Methode er zur Kompilierzeit aufrufen soll. Es ist, als würde man sich im Voraus entscheiden, welche Kleidung man trägt – man weiß im Voraus!

Funktionsüberladung

Die häufigste Form der statischen Polymorphie ist die Funktionsüberladung. Dies ist, wenn man mehrere Methoden mit demselben Namen aber unterschiedlichen Parametern hat.

Schauen wir uns ein Beispiel an:

public class Calculator
{
public int Add(int a, int b)
{
return a + b;
}

public double Add(double a, double b)
{
return a + b;
}

public string Add(string a, string b)
{
return a + b;
}
}

In diesem Beispiel haben wir drei Add-Methoden:

1. Eine, die zwei Integer addiert
2. Eine, die zwei Double-Werte addiert
3. Eine, die zwei Zeichenketten verknüpft

Nun verwenden wir unseren Calculator:

Calculator calc = new Calculator();

int sum1 = calc.Add(5, 3);            // Verwendet die Integer-Version
double sum2 = calc.Add(3.14, 2.86);   // Verwendet die Double-Version
string sum3 = calc.Add("Hello, ", "World!"); // Verwendet die Zeichenketten-Version

Console.WriteLine(sum1);  // Ausgabe: 8
Console.WriteLine(sum2);  // Ausgabe: 6
Console.WriteLine(sum3);  // Ausgabe: Hello, World!

Der Compiler weiß, welche Add-Methode er aufrufen soll, basierend auf den übergebenen Argumenttypen. Es ist, als hätte man ein Schweizer Taschenmesser – ein Werkzeug, viele Verwendungszwecke!

Dynamische Polymorphie

Dynamische Polymorphie tritt auf, wenn die Entscheidung, welche Methode aufgerufen werden soll, zur Laufzeit getroffen wird. Es ist, als würde man auf der Bühne improvisieren – man entscheidet in der Moment!

Der Schlüssel zur dynamischen Polymorphie sind die Schlüsselwörter virtual und override. Schauen wir uns ein Beispiel an:

public class Animal
{
public virtual void MakeSound()
{
Console.WriteLine("The animal makes a sound");
}
}

public class Dog : Animal
{
public override void MakeSound()
{
Console.WriteLine("The dog barks: Woof! Woof!");
}
}

public class Cat : Animal
{
public override void MakeSound()
{
Console.WriteLine("The cat meows: Meow! Meow!");
}
}

In diesem Beispiel haben wir eine Basisklasse Animal mit einer virtuellen MakeSound-Methode. Die Dog- und Cat-Klassen erben von Animal und überschreiben die MakeSound-Methode.

Nun sehen wir die dynamische Polymorphie in Aktion:

Animal myAnimal = new Animal();
Animal myDog = new Dog();
Animal myCat = new Cat();

myAnimal.MakeSound();  // Ausgabe: The animal makes a sound
myDog.MakeSound();     // Ausgabe: The dog barks: Woof! Woof!
myCat.MakeSound();     // Ausgabe: The cat meows: Meow! Meow!

Selbst wenn myDog und myCat als Animal-Typen deklariert sind, verwenden sie dennoch ihre eigenen MakeSound-Methoden. Dies ist die Magie der dynamischen Polymorphie!

Die Macht der Polymorphie

Polymorphie ermöglicht es uns, flexibler und wiederverwendbarer zu kodieren. Stellen Sie sich vor, Sie erstellen ein Spiel mit verschiedenen Charaktertypen. Jeder Charakter könnte sich unterschiedlich bewegen:

public class Character
{
public virtual void Move()
{
Console.WriteLine("The character moves.");
}
}

public class Warrior : Character
{
public override void Move()
{
Console.WriteLine("The warrior charges forward!");
}
}

public class Mage : Character
{
public override void Move()
{
Console.WriteLine("The mage teleports.");
}
}

public class Rogue : Character
{
public override void Move()
{
Console.WriteLine("The rogue sneaks silently.");
}
}

Nun können wir eine Liste von Charakteren erstellen und sie alle bewegen lassen:

List<Character> characters = new List<Character>
{
new Warrior(),
new Mage(),
new Rogue()
};

foreach (var character in characters)
{
character.Move();
}

// Ausgabe:
// The warrior charges forward!
// The mage teleports.
// The rogue sneaks silently.

Dies ist die Schönheit der Polymorphie – wir können alle diese verschiedenen Charaktere als Character-Objekte behandeln, aber sie verhalten sich alle auf ihre einzigartige Weise.

Zusammenfassung der Polymorphie-Methoden

Hier ist eine kurze Referenztabelle der Polymorphie-Methoden, die wir behandelt haben:

Methode	Typ	Beschreibung
Funktionsüberladung	Statisch	Mehrere Methoden mit demselben Namen aber unterschiedlichen Parametern
Virtual/Override	Dynamisch	Basisklasse definiert virtuelle Methoden, abgeleitete Klassen überschreiben sie

Schlussfolgerung

Herzlichen Glückwunsch! Sie haben gerade Ihre ersten Schritte in die Welt der Polymorphie gewagt. Denken Sie daran, dass das Beherrschen jeder neuen Fähigkeit Übung erfordert. Lassen Sie sich nicht entmutigen, wenn es nicht sofort klappt – weiter codieren, weiter experimentieren, und bald werden Sie wie ein echter programmierender Gestaltwandler Ihre Programme formen können!

Beim Abschied hier ein kleiner Programmierwitz für Sie: Warum bevorzugen Programmierer dunklen Modus? Weil Licht Käfer anzieht!

Fröhliches Coden, zukünftige Meister der Polymorphie!

Credits: Image by storyset