No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Polimorfismo

16/19
Recursos

¿Qué es el polimorfismo en programación orientada a objetos?

El polimorfismo es un concepto crucial en la programación orientada a objetos que permite que una clase hija pueda modificar el comportamiento de un método heredado de su clase padre. A diferencia de la abstracción, donde el método requiere ser implementado en la clase hija sin características predefinidas, el polimorfismo permite que el método exista con una implementación inicial en la clase padre, pero sea modificado en la clase hija si se desea.

Ejemplo de polimorfismo en C#

Para aplicar polimorfismo en C#, utilizamos la palabra clave virtual en el método de la clase padre. Esto permite que la clase hija opte por sobrescribir el método utilizando la palabra clave override.

public class Heroe
{
    public virtual string SalvarLaTierra()
    {
        return "Ha salvado la tierra!";
    }
}

public class SuperHeroe : Heroe
{
    public override string SalvarLaTierra()
    {
        return Nombre + " " + IdentidadSecreta + " ha salvado la tierra!";
    }
}

En este ejemplo, la clase Heroe tiene un método SalvarLaTierra que se puede sobrescribir en la clase derivada SuperHeroe. Así, SuperHeroe puede usar su versión personalizada del método sin alterar el comportamiento de la clase padre.

¿Cómo se implementa el polimorfismo?

La implementación del polimorfismo en un proyecto requiere seguir algunos pasos:

  1. Definir el método como virtual: Añadiendo virtual al método en la clase padre permite que este método sea opcionalmente sobrescrito por las clases hijas.

  2. Sobrescritura del método: La clase hija debe usar override para cambiar el comportamiento del método según sea necesario.

  3. Opciones de implementación: La clase hija puede elegir:

    • Utilizar la implementación de la clase padre y extenderla.
    • Reemplazar completamente la implementación del método padre.

Ejemplo de uso del método base

Dentro de la clase hija, es posible hacer referencia a la implementación del método padre utilizando base.

public class SuperHeroe : Heroe 
{
    public override string SalvarLaTierra() 
    {
        return base.SalvarLaTierra() + " Adicionalmente, rescató a muchos ciudadanos!";
    }
}

De esta forma, se combina lo que ofrece el padre con nuevos comportamientos específicos de la clase hija.

¿Cómo comprobar la implementación?

Probar el polimorfismo en un entorno de desarrollo integrado (IDE) como Visual Studio ayuda a confirmar que los cambios funcionan correctamente sin producir errores de compilación. Al ejecutar el proyecto, se puede observar cómo la clase hija reutiliza o modifica el comportamiento del método heredado.

Proceso de prueba

  1. Ejecutar el código: Permite observar los resultados concretos del comportamiento sobrescrito.

  2. Modificar y ajustar: Probando diferentes implementaciones para entender las ventajas del polimorfismo.

  3. Aplicar a más métodos: Se anima a los programadores a realizar ejemplos adicionales, promoviendo así el uso del polimorfismo en diferentes métodos para afianzar su comprensión.

Aplicar el polimorfismo no solo mejora la flexibilidad y reusabilidad del código, sino que también potencia tu habilidad para construir aplicaciones más dinámicas y robustas. ¡Sigue explorando y practicando este concepto esencial en programación!

Aportes 10

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Diferencias entre polimorfismo y sobrecarga
Esto puede parecer un poco confuso pero en definitiva el Polimorfismo consiste en redefinir un método de una clase padre en una clase hija. Mientras que sobrecarga es definir un nuevo método igual que otro viejo, pero cambiando el tipo o la cantidad de parámetros.

*El termino Polimorfismo se deriva de las palabras griegas "poly" (Muchos) "morphe" (Formas) , que significa muchas formas. por lo tanto, el polimorfismo* permite que objetos de diferentes clases se comporten de manera similar a través de una interfaz común o una clase base. *El polimorfismo se basa en dos conceptos claves:* *1- Herencia:* *2:Métodos polimórficos:* *En una jerarquía de clases, las clases derivadas pueden proporcionar implementaciones específicas para los métodos de la clase base. Esto permite que las clases derivadas reemplacen (anulen) los métodos de la clase base con sus propias implementaciones.*

Para hacer polimorfismo, usamosla palabra “virtual” en lugar de “abstract”. La diferencia es que ahora es opcional si hacemos la implementación en la clase hija o no.

En la clase hija podemos usar lo mismo que usa el método del padre usando “base” y agregarle más cosas o podemos definir una implementación completamente diferente

Concepto de polimorfismo en POO: es un concepto clave que permite a los objetos de diferentes clases ser tratados como objetos de una clase común.
El polimorfismo permite utilizar una única interfaz para representar diferentes tipos de datos y objetos.

## Polimorfismo en C#: **Definición:** El polimorfismo permite que diferentes objetos respondan al mismo mensaje de manera diferente. **Tipos:** * **Polimorfismo de inclusión:** Un objeto de una clase derivada puede ser utilizado donde se espera un objeto de la clase base. * **Polimorfismo de sobrecarga:** Dos o más métodos con el mismo nombre pero diferentes parámetros. **Ejemplo:** ```js public class Animal { public virtual void Hablar() { Console.WriteLine("..."); } } public class Perro : Animal { public override void Hablar() { Console.WriteLine("Guau!"); } } public class Gato : Animal { public override void Hablar() { Console.WriteLine("Miau!"); } } public void HacerHablar(Animal animal) { animal.Hablar(); } ``` **En este ejemplo:** * La función `HacerHablar` recibe un objeto de tipo `Animal` como parámetro. * Cuando se llama a `HacerHablar` con un objeto `Perro` o `Gato`, se invoca la implementación de `Hablar` de la clase derivada. **Ventajas:** * Hace que el código sea más flexible y reutilizable. * Permite escribir código que funciona con diferentes tipos de objetos sin necesidad de modificar el código.
![](https://static.platzi.com/media/user_upload/Polimorfismo-94f2e1c2-f3dd-4fa8-a736-0d61d87e83aa.jpg)
```c# using HeroApp.Enums; namespace HeroApp.Models; public class SuperPower : Power { public sealed override string Name { get; set; } public string Description { get; set; } public ElementTypeEnum Element { get; set; } public PowerQualityEnum PowerQuality { get; set; } public SuperPower() { Name = string.Empty; Description = string.Empty; Element = ElementTypeEnum.Normal; PowerQuality = PowerQualityEnum.Regular; } public override string HeroPower() { return $"This hero has cast this power {Name} with this element {Element}. *"; } public override string CastPower() { // return base.CastPower(); return $"This power {Name} has this effect {Description}"; } } ```
* Abstract: funciona como idea y te obliga a implementar el metodo en las clases hijas. * Virutal: Existe una primera implementacion en clase base y no te obliga a implentarla en las demas clases hijas.
**POLIMORFISMO CONCEPTO:** El polimorfismo permite que una clase hija tenga un comportamiento diferente al de su clase padre para un mismo método. **CONCEPTOS ANTERIORES:** Herencia: Permite a una clase hija herede métodos de su clase padre. Abstracción: La clase padre puede tener métodos abstractos, que la clase hija debe implementar obligatoriamente. **POLIMORFISMO EN C# IMPLEMENTACION:** El método en la clase padre tiene que tener una implementación.  A este método para que exista polimorfismo se le agrega el keyword “virtual”. Ej: “public virtual string SalvarLaTierra()”, en la clase Heroe. Es opcional para la clase hija sobreescribir este método. Si se sobreescribe el método en la clase hija se le agrega el keyword “override”. Ejemplo: “public override string SalvarLaTierra()”, en la clase SuperHeroe. Si queremos usar la misma implementación de la clase padre en parte del método de la clase hija usamos “base”.  Ejemplo:  return $“ {nombreSuperheroe} {base.SalvarLaTierra()}”.
`using System;` `// Clase base abstracta para representar una figura` `public abstract class Figura` `{` ` // Método abstracto para calcular el área` ` public abstract double CalcularArea();` `}` `// Clase derivada para representar un cuadrado` `public class Cuadrado : Figura` `{` ` // Propiedad para el lado del cuadrado` ` public double Lado { get; set; }` ` // Implementación del método para calcular el área de un cuadrado` ` public override double CalcularArea()` ` {` ` return Lado * Lado;` ` }` `}` `// Clase derivada para representar un círculo` `public class Circulo : Figura` `{` ` // Propiedad para el radio del círculo` ` public double Radio { get; set; }` ` // Implementación del método para calcular el área de un círculo` ` public override double CalcularArea()` ` {` ` return Math.PI * Radio * Radio;` ` }` `}` `class Program` `{` ` static void Main()` ` {` ` // Crear instancias de las clases derivadas` ` Cuadrado cuadrado = new Cuadrado { Lado = 5 };` ` Circulo circulo = new Circulo { Radio = 3 };` ` // Calcular y mostrar el área de cada figura` ` MostrarArea(cuadrado);` ` MostrarArea(circulo);` ` }` ` // Método para mostrar el área de una figura sin conocer su tipo específico` ` static void MostrarArea(Figura figura)` ` {` ` Console.WriteLine($"El área de la figura es: {figura.CalcularArea()}");` ` }` `}`