C# Language
Polimorfismo

Otro ejemplo de polimorfismo

El polimorfismo es uno de los pilares de la POO. Poly deriva de un término griego que significa "formas múltiples".

A continuación se muestra un ejemplo que exhibe polimorfismo. La clase Vehicle toma múltiples formas como clase base.

Las clases derivadas Ducati y Lamborghini heredan del Vehicle y anulan el método Display() la clase base, para mostrar sus propias 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}");
    }
}

A continuación se muestra el fragmento de código donde se exhibe el polimorfismo. El objeto se crea para el Tipo base Vehicle utilizando un vehicle variable en la Línea 1. Llama al método de clase base Display() en la Línea 2 y muestra la salida como se muestra.

 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
 }

En la Línea 3, el objeto del vehicle apunta a la clase derivada Ducati y llama a su método Display() , que muestra la salida como se muestra. Aquí viene el comportamiento polimórfico, aunque el objeto vehicle es del tipo Vehicle , se llama al método clase derivada Display() como el tipo de Ducati anula la clase base Display() método, ya que el vehicle objeto se señaló hacia Ducati .

La misma explicación es aplicable cuando invoca el método Display() del tipo Lamborghini .

La salida se muestra a continuación

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

Tipos de polimorfismo

El polimorfismo significa que una operación también se puede aplicar a valores de algunos otros tipos.

Hay múltiples tipos de polimorfismo:

• Polimorfismo ad hoc:
  contiene la function overloading . El objetivo es que un método se pueda usar con diferentes tipos sin la necesidad de ser genérico.
• Polimorfismo paramétrico:
  Es el uso de tipos genéricos. Ver genéricos
• Subtitulado:
  tiene el objetivo heredado de una clase para generalizar una funcionalidad similar

Polimorfismo ad hoc

El objetivo del Ad hoc polymorphism es crear un método, que pueda ser llamado por diferentes tipos de datos sin necesidad de una conversión de tipo en la llamada a la función o genéricos. El siguiente método (s) sumInt(par1, par2) se puede llamar con tipos de datos diferentes y tiene para cada combinación de tipos una implementación propia:

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

Aquí hay un ejemplo de llamada:

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
}

Subtitulación

Subtipo es el uso de heredar de una clase base para generalizar un comportamiento similar:

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

Ambas clases, NormalCar y ElectricCar ahora tienen un método para repostar, pero su propia implementación. Aquí hay un ejemplo:

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

La salida será la siguiente:

Repostar con gasolina
Bateria cargando