C# Language
Polimorfismo

Un altro esempio di polimorfismo

Il polimorfismo è uno dei pilastri dell'OOP. Poly deriva da un termine greco che significa "forme multiple".

Di seguito è riportato un esempio che mostra Polymorphism. La classe Vehicle assume più forme come classe base.

Le classi derivate Ducati e Lamborghini ereditano da Vehicle e sovrascrivono il metodo Display() della classe base, per visualizzare il proprio 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}");
    }
}

Di seguito è riportato lo snippet di codice in cui viene visualizzato Polymorphism. L'oggetto viene creato per il tipo di base Vehicle utilizza un vehicle variabile sulla linea 1. Chiama il metodo della classe base Display() sulla linea 2 e visualizza l'output come mostrato.

 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
 }

Alla riga 3, l'oggetto vehicle è indirizzato alla classe derivata Ducati e chiama il suo metodo Display() , che visualizza l'uscita come mostrato. Qui viene il polimorfismo, anche se l'oggetto vehicle è di tipo Vehicle , si chiama il metodo classe derivata Display() come tipo Ducati eredita dalla classe base Display() metodo, poiché il vehicle oggetto è puntato verso Ducati .

La stessa spiegazione è applicabile quando richiama il metodo Display() del tipo Lamborghini .

L'uscita è mostrata sotto

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

Tipi di polimorfismo

Il polimorfismo indica che un'operazione può essere applicata anche a valori di altri tipi.

Esistono diversi tipi di polimorfismo:

• Polimorfismo ad hoc:
  contiene function overloading . L'obiettivo è che un metodo può essere utilizzato con diversi tipi senza la necessità di essere generici.
• Polimorfismo parametrico:
  è l'uso di tipi generici. Vedi Generics
• subtyping:
  ha il target ereditato da una classe per generalizzare una funzionalità simile

Polimorfismo ad hoc

L'obiettivo del Ad hoc polymorphism è quello di creare un metodo, che può essere chiamato da diversi tipi di dati senza bisogno di conversione di tipo nella chiamata di funzione o generici. Il seguente metodo (s) sumInt(par1, par2) può essere chiamato con diversi tipi di dati e ha per ogni combinazione di tipi una propria implementazione:

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

Ecco una chiamata di esempio:

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

Sottotipo è l'uso di ereditare da una classe base per generalizzare un comportamento simile:

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

Entrambe le classi NormalCar e ElectricCar ora hanno un metodo per fare rifornimento, ma la loro stessa implementazione. Ecco un esempio:

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

L'output sarà seguito:

Rifornimento di carburante con benzina
Carica della batteria