Polimorfismo en C#

V1.0
Febrero 2014
“Providing a single interface to
Ferreiras entities of different types. . BS”

1
 Polimorfismo
• Es cuando un método con un mismo
nombre se puede procesar de diferentes
maneras.

• El polimorfismo es uno de los conceptos

fundamentales de la programación orientada
a objetos, POO

2
 Polimorfismo
• El polimorfismo proporciona las siguientes
características :

• Permite a una clase proporcionar diferentes

implementaciones de métodos que son llamados a
través del mismo nombre. Esto es llamado polimorfismo
estático.

• Permite invocar los métodos de clases derivadas

mediante una referencia a su clase base en tiempo de
ejecución. Esto es llamado polimorfismo dinámico.

3
 Polimorfismo
• El polimorfismo es de dos tipos:

• Polimorfismo estático / Sobrecarga de

métodos

• Polimorfismo dinámico / Sobreescritura

de métodos.

4
 Polimorfismo estático
• La vinculación se produce en tiempo de
compilación;

• Se implementa con la sobrecarga de

métodos, en una misma clase.

5
 Sobrecarga de métodos
La sobrecarga de métodos ( overloading
methods ) Significa definir dos o más métodos
dentro de la misma clase, los cuales tienen el
mismo nombre, pero con diferentes
declaraciones de parámetros. Los tipos de
retornos podrán ser iguales o diferentes. Lo
único que se toma en cuenta son los nombres
de los métodos y sus listas de parámetros, esto
es, la firma de los métodos.

6
 Cuando un método sobrecargado se invoca,
utiliza el tipo y / o número de argumentos como
guía para determinar qué versión del método
sobrecargado debe llamar.

 Cuando se encuentra una llamada a un

método sobrecargado, simplemente se ejecuta la
versión del método cuyos parámetros coincidan
con los argumentos utilizados en la llamada

7
 /*
polimoStatic0.cs
csc.exe 3.5

Ferreiras / C# / Polimorfismo estático ó sobrecarga de métodos (Overloading )

*/
Obsérvese que el método fofi ()
using System;
es sobrecargado 3 veces.
class Sobrecargada {
public void fofi(string cad1) {
Console.WriteLine("\n\t=> " + cad1 );
}

public void fofi(string cad, string cad2) {

Console.WriteLine( "\n\t=> Concatenando: " + cad + " " + cad2 );
}

public double fofi(double salarioAnual) {

Console.WriteLine("\n\t=> Salario anual: " + salarioAnual );
return salarioAnual/12;
}
}

8
polimoStatic0.cs

public class Tester {

public static void Main() {

Sobrecargada sobrecarga = new Sobrecargada();

double salarioMensual;
sobrecarga.fofi("El monigote de la ONU");
sobrecarga.fofi( "Ban-Kimoon, el monigote US" , " y de la OTAN" );
salarioMensual = sobrecarga.fofi(435237.12);
Console.WriteLine("\n\t=> Salario Mensual = " + salarioMensual );
}
}

9
polimoStatic0.cs

D:\Ferreiras2\C#, Mi Codigo C#>csc polimoStatic0.cs

Microsoft (R) Visual C# 2008 Compiler version 3.5.30729.1
for Microsoft (R) .NET Framework version 3.5
Copyright (C) Microsoft Corporation. All rights reserved.

D:\Ferreiras2\C#, Mi Codigo C#> polimoStatic0

=> El monigote de la ONU

=> Concatenando: Ban-Kimoon, el monigote US y de la OTAN

=> Salario anual: 435237.12

=> Salario Mensual = 36269.76

D:\Ferreiras2\C#, Mi Codigo C#>

10
 En resumen, los métodos sobrecargados:
 Tienen diferentes listas de parámetros;
 Los tipos de retorno pueden ser iguales o
diferentes. No importa;
 Pueden cambiar el modificador de acceso;
 Pueden declarar nuevas o más amplias
excepciones;
 Pueden estar en la misma clase o en una clase
derivada;
 La sobrecarga de métodos no tiene nada que
ver con la herencia y métodos virtuales.

11
 Polimorfismo estático
• Polimorfismo estático, vinculación
temprana, sobrecarga de métodos Son
todos sinónimos.
• La sobrecarga de métodos es la forma
en que C# implementa el polimorfismo
estático.

Ferreiras Polimorfismo en JAVA 12

12
 Polimorfismo estático
• Como hemos vista ya es posible definir dos o más
métodos de la misma clase que comparten el mismo
nombre, siempre y cuando sus declaraciones de
parámetros sean diferentes.
• Cuando este es el caso, los métodos se dice que están
sobrecargadas, y el proceso se conoce como sobrecarga
del método, como ya vimos.

Ferreiras Polimorfismo en JAVA 13

13
 Polimorfismo estático
• Los métodos sobrecargados deben
diferenciarse en el tipo y / o número de sus
parámetros y, aunque pueden tener diferentes
tipos de retorno, el tipo de retorno por sí solo no
es insuficiente para distinguir dos versiones de
un método.
•

Ferreiras Polimorfismo en JAVA 14

14
 Polimorfismo estático
• Cuando se encuentra una llamada a un método
sobrecargado, simplemente ejecuta la versión del
método cuyos parámetros coincidan con los
argumentos utilizados en la llamada.
• Cuando un método sobrecargado es invocado, se
utiliza el tipo y / o número de argumentos como guía
para determinar qué versión del método sobrecargado
para llamar realidad.

Ferreiras Polimorfismo en JAVA 15

15
 Polimorfismo dinámico
• Es la propiedad que tienen objetos
pertenecientes a diferentes clases, Derivadas
de una misma clase Base, de poder responder
a un mismo mensaje de diferentes formas;

• En C#, el polimorfismo dinámico se

implementa con la sobreescritura de métodos
mediante la herencia y métodos virtuales y,
también, por vía de interfaces .
16
 Sobreescritura de métodos
• La sobreescritura de métodos ( methods
overriding ) es una nueva definición, en una
clase derivada, de un método no static ya
definido en la clase base.
• El método sobrescrito tendrá en la clase
derivada el mismo modificador, el mismo tipo de
retorno, el mismo nombre y la misma lista de
parámetros, pero cuerpo diferente.
17
• En situaciones en las que sea necesario usar de
manera explícita el método de la clase base
podemos usar la palabra reservada “base” y
para llamar de manera expresa un método del
objeto actual podemos usar la palabra reservada
“this”.
• La nueva definición del método no puede
reducir la accesibilidad del método original, pero
si puede ampliarla.

18
/*
polimorDinam0.cs

Ferreiras / C# / Polimorfismo / Polimorfismo dinâmico /Overriding

*/

using System;

/////////////////

class Animal {

public virtual void mover() {

Console.WriteLine("\n\t=> Un animal se mueve !!\n");
}
}

19
polimorDinam0.cs

class Perro : Animal {

public override void mover() {

base.mover(); // invoca el metodo mover de la clase base
Console.WriteLine("\n\t=> AVISO: Los perros pueden caminar, correr y morder\n");
}

public void ladrar() {

Console.WriteLine("\n\t=> URGENTE !! Estoy ladrando\n");
}

20
polimorDinam0.cs

//////////////

class Polimorfismo0 {

public static void Main( ){

Animal unAnimal = new Perro(); // a una refBase le es asignada un objDerivada

unAnimal.mover(); // Ejecuta el metodo en la clase Perro
// unAnimal.ladrar(); // Ver NOTA 1

}
}

//////////////////

21
polimorDinam0.cs

D:\Ferreiras2\C#, Mi Codigo C#>csc polimorDinam0.cs

Microsoft (R) Visual C# 2008 Compiler version 3.5.30729.1
for Microsoft (R) .NET Framework version 3.5
Copyright (C) Microsoft Corporation. All rights reserved.

D:\Ferreiras2\C#, Mi Codigo C#>polimorDinam0

=> Un animal se mueve !!

=> AVISO: Los perros pueden caminar, correr y morder

D:\Ferreiras2\C#, Mi Codigo C#>

22
/*
polimorDinam0.cs

NOTA 1

D:\Ferreiras2\C#, Mi Codigo C#>csc polimorDinam0.cs

Microsoft (R) Visual C# 2008 Compiler version 3.5.30729.1

for Microsoft (R) .NET Framework version 3.5
Copyright (C) Microsoft Corporation. All rights reserved.

polimorDinam0.cs(68,16): error CS1061: 'Animal' does not contain a

definition for 'ladrar' and no extension method 'ladrar' accepting a
first argument of type 'Animal' could be found (are you missing a using
directive or an assembly reference?)

D:\Ferreiras2\C#, Mi Codigo C#>

*/

23
 En resumen, para sobreescribir los métodos
en la clase base:
• Los métodos debe ser virtual
• Los métodos virtual o abstract no pueden ser private
• Un método declarado static no puede ser marcado como override, virtual o abstrac
• Si un método no puede ser heredado, este no puede ser sobreescrito;
• La lista de parámetros en el método sobreescrito debe ser exactamente la misma
que la lista del método en la clase base;
• El tipo de retorno en el método sobreescrito debe ser exactamente el mismo tipo
que el del método en la clase base o un subtipo de este.
• Un constructor no puede ser sobreescrito;

24
 Polimorfismo dinámico
• La vinculación tardía Hace posible que, con un método declarado
en una clase base (o en una interface) y sobreescrito en las clases
derivadas (o en clases que implementan la interface), sea el tipo de
objeto, y no el tipo de la referencia lo que determine qué definición
del método se va a ejecutar.

• El tipo de objeto al que apunta una referencia solo puede

conocerse en tiempo de ejecución , y es por eso que el
polimorfismo dinámico necesita la vinculación tardía o dinámica.

Ferreiras Polimorfismo en JAVA 25

25
 Polimorfismo dinámico
• El polimorfismo dinámico Significa que cuando un método es
llamado, la llamada al método es vinculada al cuerpo del método
en el momento de ejecutar el programa, dinámicamente.
• En este caso, el compilador no sabe qué método es llamado en
el momento de la compilación.
• Por lo tanto, esto también se llama "polimorfismo en tiempo
de ejecución" o "enlace dinámico“. Otro nombre es “Vinculación
tardía”
• Es la capacidad de vincular una variable de referencia a más de
un tipo de objeto.

Ferreiras Polimorfismo en JAVA 26

26
 Polimorfismo dinámico
• El polimorfismo dinámico esta asociado a una
variable polimórfica de referencia;
• Variable polimórfica  Es una variable que
puede referenciar mas de un tipo de objeto, en
distintos momentos de la ejecución de un
programa ).

27
 Polimorfismo dinámico
Por ejemplo:
ClaseBase variableDeReferencia;

variableDeReferencia  Es, entonces,

una variable polimórfica porque, en = new ClaseDerivada1();
este caso, esta referenciando varios
objetos de las Derivadas de la Base.
= new ClaseDerivada2();

variableDeReferencia 

= new ClaseDerivada();

28
/*
polimorDinam1.cs
csc.exe 3.5

Ferreiras / C# / Polimorfismo dinámico, overriding

*/

using System;

////////////////////
class Animal {

public virtual void hablar() {

Console.WriteLine("\n\t=> Animal hablando\n");
}
}

29
polimorDinam1.cs

////////////////
class Mamifero : Animal {

public override void hablar(){

Console.WriteLine("\n\t=> Mamifero hablando\n");
}
}

///////////////
class Caballo : Mamifero {

public override void hablar(){

Console.WriteLine("\n\t=> Caballo hablando\n");
}
}

///////////////

30
polimorDinam1.cs

class Murcielago : Mamifero {

public override void hablar(){
Console.WriteLine("\n\t=> Murcielago hablando\n");
}
}

31
polimorDinam1.cs

/////////////
El Principio de Sustitución de Liskow
class Tester {
public static void Main() { Si se tiene una variable cuyo tipo es una
Animal refAnimal; superclase, el programa debería funcionar
correctamente si se coloca una instancia de
refAnimal = new Animal(); esa superclase o cualquiera de sus
refAnimal.hablar(); subclases en dicha variable.

refAnimal = new Mamifero(); El programa que utiliza la variable antes

refAnimal.hablar(); indicada no debería ser capaz de decir qué
clase se está utilizando, en tiempo de
refAnimal = new Caballo(); ejecución.
refAnimal.hablar();

refAnimal = new Murcielago();

refAnimal.hablar();
}
}

32
polimorDinam1.cs

D:\Ferreiras2\C#, Mi Codigo C#>csc polimorDinam1.cs

Microsoft (R) Visual C# 2008 Compiler version 3.5.30729.1
for Microsoft (R) .NET Framework version 3.5
Copyright (C) Microsoft Corporation. All rights reserved.

D:\Ferreiras2\C#, Mi Codigo C#> polimorDinam1

=> Animal hablando

=> Mamifero hablando

=> Caballo hablando

=> Murcielago hablando

D:\Ferreiras2\C#, Mi Codigo C#>

33
Polimorfismo dinámico en C# vía interface

• Se implementa declarando variables de referencia con el tipo

de la interface.

• Posteriormente, se le asigna un objeto de cualquier clase que

implemente la interface usada como tipo en la variable de
referencia.

• Utilizando la misma variable de referencia se puede invocar

métodos de diferentes clases que implementen la interface
usada.

34
Polimorfismo dinámico en C# vía interface

• Así, podremos utilizar los métodos de la

interface, vía la variable de referencia a la que
le fuese asignado un objeto de la clase que la
implementó, sin mas que conocer el actual tipo
de objeto.

• Téngase en cuenta que la clase que

implemente la interface debe implementar
todos los métodos declarados en esta ultima.
35
 Por ejemplo:

/*
polimorInterface0.cs
csc.exe 3.5

Ferreiras / C#/ Polimorfismo / Polimorfismo dinámico vía uso de interface

El nombre de una interface se puede utilizar para declarar el tipo de una variable,
el valor de la variable puede ser (de referencia) a un objeto de cualquier clase que
implemente esta interfaz. Así, podremos utilizar los métodos de la interface,
vía la variable de referencia a la que le fuese asignado un objeto de dicha clase,
sin mas que conocer el actual tipo de objeto.

Téngase en cuenta que la clase que implemente la interface debe implementar todos
los métodos declarados en esta ultima.

*/

36
polimorInterface0.cs

using System;

// Declaramos la interface

interface IProfesorEstudiante {
void elProfesor();
}

// Implementamos la interface

class Profesor : IProfesorEstudiante {

public void elProfesor() { // Como ve el Estudiante al Profesor
Console.WriteLine("\n\t* Estudiante => El profesor es el Guru de esto !!\n");
}

37
polimorInterface0.cs

class Estudiante : IProfesorEstudiante {

public void elProfesor() { // Como ve el Profesor al Estudiante
Console.WriteLine("\n\t* El Profesor => Todos tienen un 70 !!\n");
}
}

class Escuela : IProfesorEstudiante {

public void elProfesor() { // Como ve la escuela el profesor
Console.WriteLine("\n\t* La Escuela y la ANEUINF => No debes faltar a clase !!\
n");
}
public double evaluacionProfesor() { // metodo que NO esta en la interface
double evaluacion = 70;
return evaluacion;
}
}

38
polimorInterface0.cs

class Tester { Obsérvese que usamos la misma

public static void Main() {
IProfesorEstudiante varRef;
varRef = new Profesor();
varRef.elProfesor();
varRef = new Estudiante();
varRef.elProfesor();
varRef = new Escuela();
varRef.elProfesor();
variable de referencia del tipo de la
interface para ir asignándole
objetos de las clases que la
implementan y poder invocar sus
respectivos métodos. Eso también
es polimorfismo dinámico

// varRef.evaluacionProfesor(); // ERROR, ver NOTA 1

}
}

39
polimorInterface0.cs

D:\Ferreiras2\C#, Mi Codigo C#>csc polimorInterface0.cs

Microsoft (R) Visual C# 2008 Compiler version 3.5.30729.1
for Microsoft (R) .NET Framework version 3.5
Copyright (C) Microsoft Corporation. All rights reserved.

D:\Ferreiras2\C#, Mi Codigo C#> polimorInterface0

* Estudiante => El profesor es el Guru de esto !!

* El Profesor => Todos tienen un 70 !!

* La Escuela y la ANEUINF => No debes faltar a clase !!

D:\Ferreiras2\C#, Mi Codigo C#>

40
 La causa de este error es que
intentamos usar la variable de
referencia ,varRef, con un método que
polimorInterface0.cs no esta declarado en la interface usada
como tipo de la variable.
NOTA 1

D:\Ferreiras2\C#, Mi Codigo C#>csc polimorInterface0.cs

Microsoft (R) Visual C# 2008 Compiler version 3.5.30729.1
for Microsoft (R) .NET Framework version 3.5
Copyright (C) Microsoft Corporation. All rights reserved.

polimorInterface0.cs(69,19): error CS1061: 'IProfesorEstudiante' does not

contain a definition for 'evaluacionProfesor' and no extension method
'evaluacionProfesor' accepting a first argument of type
'IProfesorEstudiante' could be found (are you missing a using directive
or an assembly reference?)

D:\Ferreiras2\C#, Mi Codigo C#>

41
 Sum up of the polymorphism in C# 1
1. C# recognizes the method by its parameters and not by its name.
2. The return value/parameter type of a method is never the part of method signature if the
names of the methods are same. So this is not polymorphism.
3. Modifiers such as static are not considered as part of method signature.
4. The signature of a method consists of its name, number and types of its formal parameters. The
return type of a function is not part of the signature. Two methods can not have the same
signature and also non-members cannot have the same name as members.
5. Parameter names should be unique. And also we can not have a parameter name and a
declared variable name in the same function as same.
6. In case of pass by value, the value of the variable is passed and in the case of ref and out, the
address of the reference is passed.
7. The “this” param keyword can only be applied to the last argument of the method. So the n
number of parameters can only be at the end.
8. C# is very smart to recognize if the penultimate argument and the params have the same data
type.
9. Parameter array must be a single dimensional array.

1: Taken from: http://csharppulse.blogspot.in/ , with some extend by Ferreiras

42
EJEMPLOS

...

43
EJERCICIOS

...

44
 Referencias
• Types (C# Programming Guide)
http://msdn.microsoft.com/en-us/library/ms173104.aspx

• C# Concisely; Judith Bishop, Nigel Hospool; Pearson, Addison Wisley 2003.

• Head First C#; Andrew Stellman and Jennifer Greene ; Second Edition; O’Reilly Media,
2010.

• Desarrollo de aplicaciones .NET con Visual C#; Miguel Rodríguez Gómez-Stern, Marcos
Antonio Besteiro Gorostizaga; McGra2-Hill/Interamericana de España, S.A.U., 2002.

• Visual C# Language
http://msdn.microsoft.com/en-us/library/aa287558(v=vs.71).aspx

• ...

45
GRACIAS

46