C# Language
polymorfisme

Een ander voorbeeld van polymorfisme

Polymorfisme is een van de pijlers van OOP. Poly is afgeleid van een Griekse term die 'meerdere vormen' betekent.

Hieronder is een voorbeeld dat polymorfisme vertoont. De klasse Vehicle neemt meerdere vormen aan als basisklasse.

De afgeleide klassen Ducati en Lamborghini erven van Vehicle en overschrijven de methode Display() de basisklasse om zijn eigen 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}");
    }
}

Hieronder staat het codefragment waar polymorfisme wordt tentoongesteld. Het object is gemaakt voor het basistype Vehicle met behulp van een variabel vehicle op regel 1. Het roept de basisklasse-methode Display() op regel 2 aan en geeft de uitvoer weer zoals getoond.

 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
 }

Op regel 3 verwijst het vehicle naar de afgeleide klasse Ducati en roept de methode Display() , die de uitvoer weergeeft zoals weergegeven. Hier komt de polymorfe gedrag, terwijl het voorwerp vehicle van het type Vehicle , roept de afgeleide klasse methode Display() als type Ducati overschrijft de basisklasse Display() methode, aangezien het vehicle voorwerp gericht is naar Ducati .

Dezelfde verklaring is van toepassing wanneer deze de methode Display() het Lamborghini type oproept.

De uitvoer wordt hieronder getoond

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

Soorten polymorfisme

Polymorfisme betekent dat een bewerking ook kan worden toegepast op waarden van enkele andere typen.

Er zijn meerdere soorten polymorfisme:

• Ad hoc polymorfisme:
  bevat function overloading . Het doel is dat een methode met verschillende typen kan worden gebruikt zonder generiek te hoeven zijn.
• Parametrisch polymorfisme:
  is het gebruik van generieke typen. Zie Generics
• subtypering:
  heeft het doel van een klasse om een vergelijkbare functionaliteit te generaliseren

Ad hoc polymorfisme

Het doel van Ad hoc polymorphism is om een methode te maken die door verschillende gegevenstypen kan worden aangeroepen zonder dat typeconversie nodig is in de functieaanroep of generieke geneesmiddelen. De volgende methode (s) sumInt(par1, par2) kan met verschillende gegevenstypen worden aangeroepen en heeft voor elke combinatie van typen een eigen implementatie:

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 is een voorbeeld van een oproep:

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
}

subtypering

Subtypen is het gebruik van erven van een basisklasse om een soortgelijk gedrag te generaliseren:

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 en ElectricCar nu een methode om bij te tanken, maar hun eigen implementatie. Hier is een voorbeeld:

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

De output zal zijn:

Tanken met benzine
Batterij opladen