Polimorfismo

no se entiende muy bien pero, yo vi por otro lado que el polimorfismo es: Cuando en una relación de herencia un objeto de la superclase puede almacenar un objeto de cualquier subclase. La clase padre es compatible con sus derivados pero no al revés

Un ejemplo practico sobre el polimorfismo también puede ser si tienes una casa de cuidados de perros en donde vas a tener muchos tipos de perros. Aparte de los atributos que pueden compartir los perros también podemos tener funcionalidades compartidas por ejemplo un perro ladra.

Si queremos hacer que todos los perros ladren de forma secuencial lo podríamos hacer con el siguiente ejemplo:

public abstract class Perro 
    {
        public string Nombre { get; set; }

        public string Ladrar()
        {
            return $"{Nombre} Ladra";
        }

    }

    public class Pitbull: Perro
    {

    }

    public class Beagle: Perro
    {

    }

    public static class Program {
        public static void Main(string[] arg)
        {
            List<Perro> perros = new List<Perro>()
            {
                new Pitbull { Nombre = "Pitbull 1"},
                new Beagle { Nombre = "Beagle 1"},
                new Pitbull { Nombre = "Pitbull 2"},
                new Beagle { Nombre = "Beagle 2"},
                new Beagle { Nombre = "Beagle 3"},
                new Pitbull { Nombre = "Pitbull 3"},
                new Pitbull { Nombre = "Pitbull 4"}
                new Beagle { Nombre = "Beagle 4"},
            }

            foreach (Perror perro in perros)
            {
                Console.WriteLine(perro.ladrar());
            }
        }
    }

Este patrón de diseño es bueno para hacer sistemas de distribuciones y ejecución de motores.

Encontré esto, es la definición de polimorfismo orientado directamente a C#. No debemos confundir polimorfismo con sobrecarga. El primero es que un método cambia su comportamiento en la clase hija (si así lo desea), el segundo (sobrecarga), es la capacidad de que un método tome diferentes tipos y cantidad parámetros en su definición.
[https://docs.microsoft.com/es-es/dotnet/csharp/programming-guide/classes-and-structs/polymorphism](Polimorfismo en C#)

Polimorfismo

En polimorfismo un objeto hijo que hereda de una clase padre puede ser tratado como un objeto padre, pero al ser convertido en objeto padre ya no se podrá acceder a los atributos del objeto hijo. Por otro lado, un objeto padre no puede tratarse como un objeto hijo a menos que el objeto padre estuviera guardando un objeto hijo.

El polimorfismo maneja el paso de valores por referencia, es decir, en el ejemplo del video, instanciamos un objeto alumnoTest de Alumno, luego declaramos una variable ob de tipo ObjetoEscuelaBase que contenga al objeto alumnoTest, al hacer esto le pasamos las propiedades que comparten, a través de la herencia (Nombre, UniqeId), a ob por lo que si modificamos, por decir el Nombre en alumnoTest el cambio se verá reflejado a través de los que lo contengan, como en este caso ob, si modificamos ob el cambio también se reflejará en alumnoTest.

Cito parcialmente otra respuesta que acabo de poner:
Me gusta hacer muchas puntualizaciones cuando veo que algún ejemplo no es el correcto para explicar ciertos conceptos, pero en éste caso ésta es de las clases más claras y de hecho una buena base no sólo para C# o net Core si no para la POO en general.
No se porque hay muchas personas confundiendo polimorfismo con sobrecarga, pero googleando un poco encontré viejas referencias de php y java donde lo sugieren vagamente, pero no afirman que sea lo mismo o tenga que ver.

Si bien es cierto el curso es en español, recomendaria que el todo código se desarrolle en Ingles

En la segunda impresion de id, debe ser de ob, osea ob.UniqueId

El Polimorfismo no es más que obtener los datos del primer diseño (clase base) y reemplazarlos (clase que hereda), ojo no es lo mismo que hacer un overrider, el ejemplo del video puede generar confusión, pero ya cuando heredas estas realizando Polimorfismo.

Hay 3 tipos de Polimorfismo.

Polimorfismo por Herencia: Este tipo de polimorfismo es el mas común que existe, y tiene la facultad de heredar de una clase padre y reemplazarla.

Polimorfismo por Abstracción: Este tipo de polimorfismo se da con el uso de las clases abstractas. Pero que es una clase abstracta es aquella que además de lo normal que contiene una clase tiene comportamientos que si están definidos pero no implementados, no te obliga a implementar todos los métodos heredados, a parte recordad que una clase abstracta no se puede instanciar.

Polimorfismo por Interface: Es uno de los polimorfismos mas importantes por que esta basado por contratos, que son los encargados de decirme que puedo hacer o no y como debo de hacerlo. Una de las ventajas de hacer este tipo de polimorfismo es que oculta la implementación del comportamiento. Donde podemos ver este tipo de esquema es el WCF, por que el cliente solo puede ver el servicio y no la implementación del método.

https://codigofuentenet.wordpress.com/2012/07/17/polimorfismo-en-c/#:~:text=Hay tres tipos de polimorfismo,y puedo convertirme en ella.

Les recomiendo leer el siguiente artículo. A partir del mismo, hicé este apunte: Polimorfismo en Programación Orientada a Objetos

Construir métodos con el mismo nombre pero con comportamiento diferente

El polimorfismo es una relajación del sistema de tipos, de tal manera que una referencia a una clase (atributo, parámetro o declaración local o elemento de un vector) acepta direcciones de objetos de dicha clase y de sus clases derivadas (hijas, nietas, …).

Por ejemplo, si en Java defino la clase “Largometraje” , cuando creo objetos de la clase “Largometraje” debo declarar variables en las que indique el tipo de objeto que va a contener.

Largometraje miLargo = new Largometraje("Lo que el viento se llevó");

Esa variable miLargo, por declaración tendrá una referencia a un objeto de la clase Largometraje. Pues bien, durante toda su vida, deberá tener siempre una referencia a cualquier objeto de la misma clase. O sea, mañana no podremos guardar ni un entero en la variable, ni una cadena u otro objeto de otra clase, por ejemplo, de la clase Cortometraje.

Ahora, con el polimorfismo, podríamos crear una clase “superior” llamada Cine la cual sea “padre/superclase” de Largometraje y Cortometraje. Con esto, conseguimos por ejemplo un array en donde podamos meter cortometrajes y largometrajes al mismo tiempo:

Cine[] misPeliculas = new Cine[5];

Además, uno podría tener varios tipos de Largometraje, por ejemplo Documental Película, etc. Imaginemos que en la clase Cine, tenemos un método llamado reproducir(). Este método podrá recibir como parámetro aquello que quieres emitir en una sala de cine y podrán llegarte a veces objetos de la clase Película y otras veces objetos de la clase Documental:

reproducir(Pelicula peliculaParaReproducir)
reproducir(Documental documentalParaReproducir)

El código de ambos es igual, poner la película en el proyector, darle a play, crear un registro con el número de entradas vendidas, darle a stop cuando llega al final, etc.

Acá es donde se ve la magia del polimorfismo, porque podemos hacer un único método reproducir() en donde se puede recibir todo tipo de elementos, ya sea Documentales Películas o cualquier otro elemento que sea heredado desde Largometraje:

reproducir(Largometraje elementoParaReproducir)

Incluso, si mañana quieres reproducir otro tipo de cinta, no tendrás que tocar la clase “Cine” y el método “reproducir()”. Siempre que aquello que quieras reproducir sea de la clase “Largometraje” o una clase hija, el método te lo aceptará.

Es polimorfismo NO poliformismo.

¿A nadie le ha dado error el constructor de Alumnos?
Sigo sin terminar de entender como puede poner Nombre en el constructor si no existe ningún constructor así para alumnos.

se que el profesor explica muy bien, pero tuve que ver otro ejemplo para reafirmar

F en el chat por la cancelacion indirecta de House of Cards :’(

Este seria un ejemplo acorde con lo que entendi con poliformismo

<using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Estudiantes
{
    interface Animales
    {
        String obtenerRaza();
    }
}
>

Clases que la implementa

<using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Estudiantes
{
    class Cerdo : Animales
    {
        public string obtenerRaza()
        {
            return "Crianza";
        }
    }
}
>

<using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Estudiantes
{
    class Perro : Animales
    {
        public string obtenerRaza()
        {
            return "Domestica";
        }
    }
}
>

Button que implementa las clases

<using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Estudiantes
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Triangulo triangulo = new Triangulo();
            triangulo.CalculcarArea();
        }

        private void button2_Click(object sender, EventArgs e)
        {
            Perro perro = new Perro();
            Cerdo cerdo = new Cerdo();
            Console.WriteLine(perro.obtenerRaza());
            Console.WriteLine(cerdo.obtenerRaza());
        }
    }
}
>

Salida al ejecutar

‘Estudiantes.exe’ (CLR v4.0.30319: DefaultDomain): ‘C:\Windows\Microsoft.Net\assembly\GAC_32\mscorlib\v4.0_4.0.0.0__b77a5c561934e089\mscorlib.dll’ cargado. Se omitió la carga de símbolos. El módulo está optimizado y la opción del depurador ‘Sólo mi código’ está habilitada.
‘Estudiantes.exe’ (CLR v4.0.30319: DefaultDomain): ‘C:\Users\Sem-6-INGENIERIAINDU\source\repos\Estudiantes\Estudiantes\bin\Debug\Estudiantes.exe’ cargado. Símbolos cargados.
‘Estudiantes.exe’ (CLR v4.0.30319: Estudiantes.exe): ‘C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System.Windows.Forms\v4.0_4.0.0.0__b77a5c561934e089\System.Windows.Forms.dll’ cargado. Se omitió la carga de símbolos. El módulo está optimizado y la opción del depurador ‘Sólo mi código’ está habilitada.
‘Estudiantes.exe’ (CLR v4.0.30319: Estudiantes.exe): ‘C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System\v4.0_4.0.0.0__b77a5c561934e089\System.dll’ cargado. Se omitió la carga de símbolos. El módulo está optimizado y la opción del depurador ‘Sólo mi código’ está habilitada.
‘Estudiantes.exe’ (CLR v4.0.30319: Estudiantes.exe): ‘C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System.Drawing\v4.0_4.0.0.0__b03f5f7f11d50a3a\System.Drawing.dll’ cargado. Se omitió la carga de símbolos. El módulo está optimizado y la opción del depurador ‘Sólo mi código’ está habilitada.
‘Estudiantes.exe’ (CLR v4.0.30319: Estudiantes.exe): ‘C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System.Configuration\v4.0_4.0.0.0__b03f5f7f11d50a3a\System.Configuration.dll’ cargado. Se omitió la carga de símbolos. El módulo está optimizado y la opción del depurador ‘Sólo mi código’ está habilitada.
‘Estudiantes.exe’ (CLR v4.0.30319: Estudiantes.exe): ‘C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System.Core\v4.0_4.0.0.0__b77a5c561934e089\System.Core.dll’ cargado. Se omitió la carga de símbolos. El módulo está optimizado y la opción del depurador ‘Sólo mi código’ está habilitada.
‘Estudiantes.exe’ (CLR v4.0.30319: Estudiantes.exe): ‘C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System.Xml\v4.0_4.0.0.0__b77a5c561934e089\System.Xml.dll’ cargado. Se omitió la carga de símbolos. El módulo está optimizado y la opción del depurador ‘Sólo mi código’ está habilitada.
Domestica
Crianza
El programa ‘[5864] Estudiantes.exe: Seguimiento de programa’ terminó con código 0 (0x0).
El programa ‘[5864] Estudiantes.exe’ terminó con código -1 (0xffffffff).

entonces que caso tiene declarar una clase abstracta si de todas formas se puede crear “haciendo trampa”?

No recomiendo decir en algunos paises fuera de Colombia "tu amigo el pito "

Si alguien en el 2022 mira este curso y tiene dudas con el polimorfismo al igual que yo, este articulo de la web me ayudó a entenderlo mejor: https://desarrolloweb.com/articulos/polimorfismo-programacion-orientada-objetos-concepto.html

No creo que sea el mejor ejemplo para explicar el concepto de Polimorfismo. Personalmente entiendo lo siguiente. Polimorfismo quiere decir Múltiples formas. Bajo esa definición yo puedo tener un Método que llamandose igual en diferentes clases al utilizarlo genera resultados diferentes. Es decir llamo a un método que tiene el mismo nombre en diferentes clases y el resultado es diferente. Ejemplo pintar. Una clase puede pintar un Cuadrado. otra clase pinta un Poligono etc, etc. Sin embargo interesante lo que explica Juan Carlos…

Muy buena la clase, pero en esta parte se entiende que el prode queria imprimir ob.UniqueId despues de ob.Nombre

Sueles confundirte en el copy/paste, en este ejemplo obviamente será el mismo objeto ID ya que imprimiste las mismas variables. { alumno.Test.UniqueId }

En la línea 34 en vez de alumnoTest era ob.

Un video Interactivo para una mejor comprensión de Polimorfismo.

https://www.youtube.com/watch?v=bblFTvuk4pY&t=21s

Denominamos polimorfismo al mecanismo que nos permite tener un método en una clase padre como vimos en la herencia (link) y sobrescribirlo en la clase hija.

Esto quiere decir que tendremos el mismo método en ambas clases, pero en la clase hija realizara diferentes acciones. Por lo que el polimorfismo es también denominado sobreescritura de métodos.

En mi caso entendía y utilizaba el concepto de polimorfismo para tener distintos métodos con el mismo nombre que aceptaran diferentes parámetros.

Ejm:

public void Saludar(String msg) {
Console.WriteLine("Hola "+ msg);
}

public void Saludar(Alumno objAlumno) {
Console.WriteLine("Hola "+ objAlumno.Nombre);
}

public void Saludar(int option)
{
switch(option)
{
case 1:
Console.WriteLine("Hola desde la opción 1 con int);
break;

default:
Console.WriteLine("Hola genérico");
break;

}
}

A mi entender y apreciación esta clase tiene que ver más con Herencia que con Polimorfismo…

Interesante

🤯

Excelente explicación para un concepto tan complejo como lo es el polimorfismo.

muy bien explicado

hereda pero no tanto :v

En visual studio code hay shortcuts que permiten cerrar todas las secciones de codigo (CTRL + K + 0) y abrirlas (CTRL + K + J). Uan vez cerradas todas podemos ir abriendo solo lo que necesitamos usando los … que aparecen al lado derecho de las secciones o regiones.

En Visual studio Community esta funcionalidad es mas amigable y se usan los comandos:

• CTRL + M + M: cierra la región o sección de código (ejem: método, ciclo, condicional, etc) en que se tiene el cursor.
• CTRL + M + L: cierra todas las secciones del archivo al maximo, solo queda usings y namespace y en caso de estar todo cerrado abre todas las secciones nuevamente.
• CTRL + M + O: Cierra todas las secciones menos las clase.

Cuando el Alumno pasa a ser ObjetoEscuelaBase y luego pasa a ser Alumno de nuevo por conversion forzosa, se conservan las evaluaciones o se perdio esa informacion?

muy buenas clases, he entendido mejor que nunca como funciona y para que la herencia.

Los objetos de una clase derivada pueden ser tratados como objetos de una clase base en lugares como parámetros de métodos y colecciones o matrices. Cuando ocurre, el tipo declarado del objeto ya no es idéntico a su tipo en tiempo de ejecución.
Las clases base pueden definir e implementar métodos virtuales, y las clases derivadas pueden invalidarlos, lo que significa que pueden proporcionar su propia definición e implementación.

Una variable de una clase padre puede igualarse a una variable de una clase hija. Pero una variable de de una clase hija no puede igualarse a una variable de una clase padre? 🤯🤯🤯

y que ventajas tiene el polimorfismo?