Aprendiendo sobre Polimorfismo de Sobrecarga en C#

El polimorfismo de sobrecarga permite que un mismo método tenga diferentes implementaciones según los parámetros que reciba. Esto significa que podemos definir múltiples métodos con el mismo nombre pero diferentes tipos o cantidades de argumentos.

¿Qué es el polimorfismo de sobrecarga?

La sobrecarga de métodos permite utilizar el mismo nombre para diferentes métodos, lo que ayuda a mantener un código más limpio y legible. El compilador determina qué versión del método debe ejecutarse basándose en la firma del método (nombre y parámetros).

Ejemplo práctico 1: Calcular área

Imaginemos que queremos crear un método para calcular el área de diferentes formas: un cuadrado y un rectángulo. Usaremos sobrecarga para definir un único método CalcularArea que se adapte a ambos casos.

using UnityEngine;

public class Formas
{
    // Método para calcular el área de un cuadrado
    public float CalcularArea(float lado)
    {
        return lado * lado;
    }

    // Método para calcular el área de un rectángulo
    public float CalcularArea(float largo, float ancho)
    {
        return largo * ancho;
    }
}

public class EjemploSobrecarga : MonoBehaviour
{
    void Start()
    {
        Formas formas = new Formas();
        
        float areaCuadrado = formas.CalcularArea(5); // Área del cuadrado
        float areaRectangulo = formas.CalcularArea(5, 10); // Área del rectángulo
        
        Debug.Log("Área del cuadrado: " + areaCuadrado);
        Debug.Log("Área del rectángulo: " + areaRectangulo);
    }
}
            

¡Código copiado al portapapeles!

Ejemplo práctico 2: Mostrar información de un libro

Ahora, crearemos un método para mostrar información de un libro. Este método podrá aceptar diferentes parámetros para mostrar información básica o información detallada.

public class Libro
{
    public string Titulo { get; set; }
    public string Autor { get; set; }

    // Método para mostrar información básica
    public void MostrarInformacion()
    {
        Debug.Log("Título: " + Titulo);
    }

    // Método para mostrar información detallada
    public void MostrarInformacion(string autor)
    {
        Debug.Log("Título: " + Titulo + ", Autor: " + autor);
    }
}

public class EjemploSobrecargaLibros : MonoBehaviour
{
    void Start()
    {
        Libro libro = new Libro();
        libro.Titulo = "Cien años de soledad";
        libro.Autor = "Gabriel García Márquez";

        libro.MostrarInformacion(); // Muestra solo el título
        libro.MostrarInformacion(libro.Autor); // Muestra título y autor
    }
}
            

¡Código copiado al portapapeles!

Explicación de los ejemplos

• En el primer ejemplo, hemos creado un método CalcularArea que puede calcular el área de un cuadrado con un solo parámetro (lado) o de un rectángulo con dos parámetros (largo y ancho).
• En el segundo ejemplo, el método MostrarInformacion tiene dos versiones: una que muestra solo el título y otra que incluye el autor. Esto permite adaptar la salida según la información disponible.

Ventajas del polimorfismo de sobrecarga

• Legibilidad: Facilita la comprensión del código al usar nombres de métodos coherentes.
• Mantenimiento: Hace que el código sea más fácil de mantener y modificar.
• Organización: Permite agrupar métodos relacionados bajo un mismo nombre, lo que organiza mejor la funcionalidad de la clase.

Resumen

El polimorfismo de sobrecarga es una herramienta poderosa en C# que permite definir múltiples métodos con el mismo nombre pero diferentes parámetros. Esto mejora la legibilidad y el mantenimiento del código, ya que podemos usar un mismo nombre para métodos que realizan funciones similares con diferentes datos. A través de ejemplos prácticos como calcular áreas y mostrar información, podemos ver cómo esta técnica se aplica en situaciones reales.

Necesitas subir de nivel para ver este contenido. Sigue interactuando con las entradas de tu nivel.