C# Language
Wielopostaciowość

Kolejny przykład polimorfizmu

Polimorfizm jest jednym z filarów OOP. Poli pochodzi od greckiego terminu, który oznacza „wiele form”.

Poniżej znajduje się przykład, który wykazuje polimorfizm. Klasa Vehicle przyjmuje wiele postaci jako klasę podstawową.

Klasy pochodne Ducati i Lamborghini dziedziczą z Vehicle i zastępują metodę Display() klasy podstawowej, aby wyświetlić własne 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}");
    }
}

Poniżej znajduje się fragment kodu, w którym eksponowany jest polimorfizm. Obiekt jest tworzony dla typu podstawowego Vehicle za pomocą vehicle zmiennego w linii 1. W linii 2 wywołuje metodę klasy bazowej Display() i wyświetla dane wyjściowe, jak pokazano.

 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
 }

W linii 3 obiekt vehicle jest wskazywany na pochodną klasę Ducati i wywołuje metodę Display() , która wyświetla dane wyjściowe, jak pokazano. Oto zachowanie polimorficzne, mimo że obiekt vehicle jest typu Vehicle , wywołuje metodę klasy pochodnej Display() ponieważ typ Ducati przesłania metodę klasy Display() , ponieważ obiekt vehicle jest skierowany w stronę Ducati .

To samo wyjaśnienie ma zastosowanie, gdy wywołuje metodę Display() typu Lamborghini .

Dane wyjściowe pokazano poniżej

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

Rodzaje polimorfizmu

Polimorfizm oznacza, że operację można również zastosować do wartości niektórych innych typów.

Istnieje wiele rodzajów polimorfizmu:

• Polimorfizm ad hoc:
  zawiera function overloading . Celem jest to, że Metodę można stosować z różnymi typami bez potrzeby jej ogólnego charakteru.
• Polimorfizm parametryczny:
  jest użycie typów ogólnych. Zobacz ogólne
• Subtyping:
  ma dziedziczenie celu klasy w celu uogólnienia podobnej funkcjonalności

Polimorfizm ad hoc

Celem Ad hoc polymorphism jest stworzenie metody, która może być wywoływana przez różne typy danych bez potrzeby konwersji typu w wywołaniu funkcji lub ogólnych. Następujące metody sumInt(par1, par2) mogą być wywoływane z różnymi typami danych i dla każdej kombinacji typów mają własną implementację:

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);
}

Oto przykładowe połączenie:

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 to użycie dziedziczenia z klasy podstawowej w celu uogólnienia podobnego zachowania:

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");    
    }
}

Obie klasy NormalCar i ElectricCar mają teraz metodę tankowania, ale mają własną implementację. Oto przykład:

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

Dane wyjściowe będą następujące:

Tankowanie benzyny
Ładowanie baterii