El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Polimorfismo

Siguiente ►
►

El polimorfismo es uno de los pilares fundamentales de la Programación Orientada a Objetos (POO). En términos simples, el polimorfismo permite que una entidad, como una función o un objeto, tome múltiples formas. En C#, el polimorfismo se puede lograr principalmente a través de la herencia y las interfaces.

Conceptos Clave

  1. Polimorfismo en Tiempo de Compilación (Sobrecarga de Métodos)
  2. Polimorfismo en Tiempo de Ejecución (Sobrescritura de Métodos)
  3. Uso de Interfaces para Polimorfismo
  4. Clases Abstractas y Polimorfismo

Polimorfismo en Tiempo de Compilación

El polimorfismo en tiempo de compilación se logra mediante la sobrecarga de métodos. Esto significa que puedes tener múltiples métodos con el mismo nombre pero con diferentes parámetros.

Ejemplo de Sobrecarga de Métodos

public class Calculadora
{
    // Método para sumar dos enteros
    public int Sumar(int a, int b)
    {
        return a + b;
    }

    // Método para sumar tres enteros
    public int Sumar(int a, int b, int c)
    {
        return a + b + c;
    }

    // Método para sumar dos números de punto flotante
    public double Sumar(double a, double b)
    {
        return a + b;
    }
}

En este ejemplo, la clase Calculadora tiene tres métodos Sumar con diferentes firmas. El compilador decide cuál método llamar en función de los argumentos proporcionados.

Polimorfismo en Tiempo de Ejecución

El polimorfismo en tiempo de ejecución se logra mediante la sobrescritura de métodos. Esto permite que una subclase proporcione una implementación específica de un método que ya está definido en su clase base.

Ejemplo de Sobrescritura de Métodos

public class Animal
{
    public virtual void HacerSonido()
    {
        Console.WriteLine("El animal hace un sonido");
    }
}

public class Perro : Animal
{
    public override void HacerSonido()
    {
        Console.WriteLine("El perro ladra");
    }
}

public class Gato : Animal
{
    public override void HacerSonido()
    {
        Console.WriteLine("El gato maúlla");
    }
}

En este ejemplo, Perro y Gato sobrescriben el método HacerSonido de la clase base Animal. La palabra clave override se utiliza para indicar que el método está sobrescribiendo una implementación en la clase base.

Uso de Polimorfismo en Tiempo de Ejecución

Animal miAnimal;

miAnimal = new Perro();
miAnimal.HacerSonido(); // Salida: El perro ladra

miAnimal = new Gato();
miAnimal.HacerSonido(); // Salida: El gato maúlla

Aquí, la variable miAnimal puede referirse a un objeto de tipo Perro o Gato, y el método HacerSonido se llama en función del tipo real del objeto al que se refiere miAnimal.

Uso de Interfaces para Polimorfismo

Las interfaces también permiten el polimorfismo. Una interfaz define un contrato que las clases pueden implementar.

Ejemplo de Interfaces

public interface IVehiculo
{
    void Conducir();
}

public class Coche : IVehiculo
{
    public void Conducir()
    {
        Console.WriteLine("Conduciendo un coche");
    }
}

public class Bicicleta : IVehiculo
{
    public void Conducir()
    {
        Console.WriteLine("Conduciendo una bicicleta");
    }
}

Uso de Polimorfismo con Interfaces

IVehiculo miVehiculo;

miVehiculo = new Coche();
miVehiculo.Conducir(); // Salida: Conduciendo un coche

miVehiculo = new Bicicleta();
miVehiculo.Conducir(); // Salida: Conduciendo una bicicleta

Clases Abstractas y Polimorfismo

Las clases abstractas pueden contener métodos abstractos que deben ser implementados por las clases derivadas. Esto también permite el polimorfismo.

Ejemplo de Clases Abstractas

public abstract class Forma
{
    public abstract void Dibujar();
}

public class Circulo : Forma
{
    public override void Dibujar()
    {
        Console.WriteLine("Dibujando un círculo");
    }
}

public class Cuadrado : Forma
{
    public override void Dibujar()
    {
        Console.WriteLine("Dibujando un cuadrado");
    }
}

Uso de Polimorfismo con Clases Abstractas

Forma miForma;

miForma = new Circulo();
miForma.Dibujar(); // Salida: Dibujando un círculo

miForma = new Cuadrado();
miForma.Dibujar(); // Salida: Dibujando un cuadrado

Ejercicio Práctico

Ejercicio

  1. Crea una clase base llamada Empleado con un método virtual CalcularSalario.
  2. Crea dos clases derivadas, EmpleadoTiempoCompleto y EmpleadoMedioTiempo, que sobrescriban el método CalcularSalario.
  3. En la clase EmpleadoTiempoCompleto, el salario se calcula como horasTrabajadas * tarifaPorHora.
  4. En la clase EmpleadoMedioTiempo, el salario se calcula como horasTrabajadas * tarifaPorHora * 0.5.
  5. Crea una lista de Empleado y añade instancias de EmpleadoTiempoCompleto y EmpleadoMedioTiempo.
  6. Itera sobre la lista y llama al método CalcularSalario para cada empleado.

Solución

public abstract class Empleado
{
    public string Nombre { get; set; }
    public int HorasTrabajadas { get; set; }
    public double TarifaPorHora { get; set; }

    public abstract double CalcularSalario();
}

public class EmpleadoTiempoCompleto : Empleado
{
    public override double CalcularSalario()
    {
        return HorasTrabajadas * TarifaPorHora;
    }
}

public class EmpleadoMedioTiempo : Empleado
{
    public override double CalcularSalario()
    {
        return HorasTrabajadas * TarifaPorHora * 0.5;
    }
}

public class Program
{
    public static void Main()
    {
        List<Empleado> empleados = new List<Empleado>
        {
            new EmpleadoTiempoCompleto { Nombre = "Juan", HorasTrabajadas = 40, TarifaPorHora = 20 },
            new EmpleadoMedioTiempo { Nombre = "Ana", HorasTrabajadas = 20, TarifaPorHora = 15 }
        };

        foreach (var empleado in empleados)
        {
            Console.WriteLine($"Salario de {empleado.Nombre}: {empleado.CalcularSalario()}");
        }
    }
}

Salida Esperada

Salario de Juan: 800
Salario de Ana: 150

Conclusión

El polimorfismo es una característica poderosa de la Programación Orientada a Objetos que permite que una entidad tome múltiples formas. En C#, se puede lograr mediante la sobrecarga de métodos, la sobrescritura de métodos, el uso de interfaces y clases abstractas. Comprender y utilizar el polimorfismo te permitirá escribir código más flexible y extensible.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados