C# Language
Polymorphismus

Ein anderes Polymorphismus-Beispiel

Polymorphismus ist eine der Säulen der OOP. Poly leitet sich von einem griechischen Begriff ab, der "mehrere Formen" bedeutet.

Unten ist ein Beispiel, das Polymorphismus zeigt. Die Klasse Vehicle nimmt mehrere Klassen als Basisklasse an.

Die abgeleiteten Klassen Ducati und Lamborghini erben von Vehicle und überschreiben die Display() Methode der Basisklasse, um ihre eigenen NumberOfWheels .

public class Vehicle
{
    protected int NumberOfWheels { get; set; } = 0;
    public Vehicle()
    {
    }

    public virtual void Display()
    {
        Console.WriteLine($"The number of wheels for the {nameof(Vehicle)} is {NumberOfWheels}");
    }
}

public class Ducati : Vehicle
{
    public Ducati()
    {
        NoOfWheels = 2;
    }

    public override void Display()
    {
        Console.WriteLine($"The number of wheels for the {nameof(Ducati)} is {NumberOfWheels}");
    }
}

public class Lamborghini : Vehicle
{
    public Lamborghini()
    {
        NoOfWheels = 4;
    }

    public override void Display()
    {
        Console.WriteLine($"The number of wheels for the {nameof(Lamborghini)} is {NumberOfWheels}");
    }
}

Unten ist der Code-Ausschnitt, in dem Polymorphismus gezeigt wird. Das Objekt wird für den Basistyp Vehicle mit einem variablen vehicle in Zeile 1 erstellt. Es ruft die Basisklassenmethode Display() in Zeile 2 auf und zeigt die Ausgabe wie gezeigt an.

 static void Main(string[] args)
 {
    Vehicle vehicle = new Vehicle();    //Line 1
    vehicle.Display();                  //Line 2  
    vehicle = new Ducati();             //Line 3
    vehicle.Display();                  //Line 4
    vehicle = new Lamborghini();        //Line 5
    vehicle.Display();                  //Line 6
 }

In Zeile 3 zeigt das vehicle auf die abgeleitete Klasse Ducati und ruft seine Display() Methode auf, die die Ausgabe wie gezeigt anzeigt. Hier kommt das polymorphe Verhalten, obwohl das Objekt vehicle vom Typ Vehicle , ruft er die abgeleitete Klasse Methode Display() als Typ Ducati überschreibt die Basisklasse Display() Methode, da das vehicle Objekt in Richtung gerichtet ist Ducati .

Die gleiche Erklärung gilt, wenn die Display() Methode des Lamborghini Typs Display() wird.

Die Ausgabe wird unten gezeigt

The number of wheels for the Vehicle is 0        // Line 2 
The number of wheels for the Ducati is 2         // Line 4
The number of wheels for the Lamborghini is 4    // Line 6

Arten von Polymorphismus

Polymorphismus bedeutet, dass eine Operation auch auf Werte anderer Typen angewendet werden kann.

Es gibt mehrere Arten von Polymorphismus:

• Ad-hoc-Polymorphismus:
  enthält function overloading . Das Ziel ist, dass eine Methode mit verschiedenen Typen verwendet werden kann, ohne generisch zu sein.
• Parametrischer Polymorphismus:
  ist die Verwendung von generischen Typen. Siehe Generics
• Subtyping:
  hat das Ziel, eine Klasse zu vererben, um eine ähnliche Funktionalität zu verallgemeinern

Ad-hoc-Polymorphismus

Ziel des Ad hoc polymorphism ist die Erstellung einer Methode, die von verschiedenen Datentypen aufgerufen werden kann, ohne dass eine Typumwandlung im Funktionsaufruf oder in den Generics erforderlich ist. Die folgenden Methoden sumInt(par1, par2) können mit verschiedenen Datentypen aufgerufen werden und haben für jede Kombination von Typen eine eigene Implementierung:

public static int sumInt( int a, int b)
{
    return a + b;    
}

public static int sumInt( string a, string b)
{
    int _a, _b;
    
    if(!Int32.TryParse(a, out _a))
        _a = 0;
    
    if(!Int32.TryParse(b, out _b))
        _b = 0;
    
    return _a + _b;
}

public static int sumInt(string a, int b)
{
    int _a;
    
    if(!Int32.TryParse(a, out _a))
        _a = 0;    
    
    return _a + b;
}

public static int sumInt(int a, string b)
{        
    return sumInt(b,a);
}

Hier ein Beispiel für einen Anruf:

public static void Main()
{
    Console.WriteLine(sumInt( 1 , 2 ));  //  3
    Console.WriteLine(sumInt("3","4"));  //  7
    Console.WriteLine(sumInt("5", 6 ));  // 11
    Console.WriteLine(sumInt( 7 ,"8"));  // 15
}

Subtyping

Subtyping ist die Verwendung von Vererbung von einer Basisklasse, um ein ähnliches Verhalten zu verallgemeinern:

public interface Car{
    void refuel();
}

public class NormalCar : Car
{
    public void refuel()
    {
        Console.WriteLine("Refueling with petrol");    
    }
}

public class ElectricCar : Car
{
    public void refuel()
    {
        Console.WriteLine("Charging battery");    
    }
}

Beide Klassen NormalCar und ElectricCar verfügen jetzt über eine Methode zum Auftanken, jedoch über eine eigene Implementierung. Hier ist ein Beispiel:

public static void Main()
{
    List<Car> cars = new List<Car>(){
        new NormalCar(),
        new ElectricCar()
    };
    
    cars.ForEach(x => x.refuel());
}

Die Ausgabe war wie folgt:

Tanken mit Benzin
Batterie aufladen