Unidad 2 Herencia y polimorfismo en lenguaje de programacion CSharp

Lenguaje

•

UNAM

Vitoria Garcés

25/8/2023

¡Este material tiene más páginas!

Entonces, ¿te gustó este material?

Ayude a animar a otros estudiantes a mejorar el contenido

¿Te gustó este material? ¡Compartir! 🧡

Lenguaje

11.844 Materiales compartidos

Descarga la aplicación para disfrutar aún más

Lea materiales sin conexión, sin usar Internet. Además de muchas otras características!

Vista previa del material en texto

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

1 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Ingeniería en Desarrollo de Software
8º cuatrimestre

Programa de la asignatura:
Programación .NET II

Unidad 2. Herencia y polimorfismo en el lenguaje de
programación C Sharp

Clave:
150930934

Universidad Abierta y a Distancia de México
UnADM

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

2 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Índice

Presentación de la unidad ................................................................................................. 3
Propósitos .......................................................................................................................... 3
Competencia específica ..................................................................................................... 4
2.1. Herencia en C Sharp ................................................................................................. 4
2.1.1. Herencia simple .................................................................................................... 7
2.1.2. Clases abstractas ............................................................................................... 14
2.1.3. Clases selladas .................................................................................................. 22
Actividad 1. Herencia ....................................................................................................... 26
2.1.4. Interfaces ........................................................................................................... 27
Actividad 2. Herencia mediante C Sharp.......................................................................... 36
2.2. Polimorfismo en C Sharp ....................................................................................... 37
2.2.1. Métodos polimórficos .......................................................................................... 39
2.2.2. Métodos genéricos ............................................................................................. 48
Actividad 3. Métodos polimórficos .................................................................................... 50
2.3. Sobreescritura en C Sharp ..................................................................................... 51
2.3.1. Modificador virtual ............................................................................................. 52
2.3.2. Modificador override .......................................................................................... 53
Autoevaluación ................................................................................................................ 56
Evidencia de aprendizaje. Herencia simple, polimorfismo y sobreescritura ...................... 57
Cierre de la unidad .......................................................................................................... 58
Para saber más ............................................................................................................... 58
Fuentes de consulta ........................................................................................................ 59

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

3 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Unidad 2. Herencia y polimorfismo en el lenguaje de programación
C Sharp

Presentación de la unidad

Bienvenido a la nueva unidad de programación en .Net.II.

Herencia y polimorfismo en el lenguaje de programación C Sharp es una unidad muy
importante. Aquí trabajarás con esos dos conceptos fundamentales de la programación
orientada a objetos basada en C Sharp.

La filosofía de programación orientada a objetos maneja como pilar fundamental el
concepto de reutilización de código; trata de evitar que los mismos procedimientos se
reinventen una y otra vez.

Hay dos formas de reutilización de código: la herencia y el polimorfismo. En la primera, el
código se reutiliza de una clase ya existente; en la segunda, un método puede realizar
diferentes funciones.

Estos dos conceptos te serán de gran utilidad en el desarrollo de tu carrera, los cuales se
explican en los temas 2.1. Herencia en C Sharp y 2.2. Polimorfismo en C Sharp, que
forman parte de esta segunda unidad. En el 2.3. Sobre escritura en C Sharp, observarás
que es posible que las clases que heredan cambien la funcionalidad de las ya existentes.

Propósitos

Al término de esta unidad lograrás:

 Entender el concepto de herencia y la forma de construirla dentro de C Sharp.
 Manejar los métodos polimórficos en el contexto de problemas planteados.
 Identificar la utilidad de los métodos polimórficos al construir programas con el
lenguaje C Sharp.
 Identificar la utilidad del uso de interfaces en el contexto de un problema.
 Comprender el concepto de sobreescritura y su importancia en los procesos de
herencia para la programación orientada a objetos en C Sharp.

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

4 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Competencia específica

 Implementar los conceptos de herencia, interfaces, polimorfismo, sobreescritura y
seguir los estándares propuestos por la tecnología .NET; esto con el fin de
entender los conceptos de programación orientada a objetos en dicha plataforma.

2.1. Herencia en C Sharp

Un programa simple en C# puede usar una o dos clases; sin embargo, es seguro que en
problemas reales sea necesario utilizar una gran cantidad. Muchas de estas clases
pueden necesitar campos o métodos similares, y sería lógico compartir el código común
entre ellas; dicho en otras palabras: reutilizar el código.

C# incluye el concepto orientado a objetos de herencia como una “forma de reutilización
de software con la que los programadores crean clases que absorben los datos y
comportamientos de una clase existente y los mejoran con nuevas capacidades” (Deitel y
Deitel, 2007, p. 665). Una clase, que puede ser llamada padre, sede atributos a otra
nombrada hija o derivada; de esta forma, en lugar de reescribir el código se reutiliza.

El concepto de herencia en la programación orientada a objetos fue pensado,
principalmente, para evitar la reescritura de datos y métodos en clases que puedan
reutilizarse; reducir los errores al volver a escribir códigos similares; ahorrar tiempo en la
programación; reforzar la reutilización de software de alta calidad, y comprobar, depurar y
garantizar al máximo la implementación de un sistema en forma efectiva (Deitel y Deitel,
2007).

La herencia también ayuda en los procedimientos de especialización. Una clase, a
medida que se hereda, se especializa en las clases derivadas.

Otra de las grandes ventajas en el uso de la herencia consiste en que al corregirse el
error, sólo una vez, del dato que se heredará de la clase “base”, todas las clases
subsecuentes se corregirán en consecuencia

Este concepto de herencia es tan importante en el desarrollo de aplicaciones que Andrew
Troelsen, en su obra Pro C# 2010 and the .NET 4 Platform, la llama “Pilar de la
programación orientada a objetos”, porque permite crear jerarquías de clases
relacionadas por funcionalidades similares (al compartir datos y métodos comunes). Aquí
aparece el término que permite entender la herencia y que es la parte medular de esta
tecnología: es-un (Deitel yDeitel, 2007, p. 666). Este término señala una relación entre
dos clases, y se basa en “la idea […] de la herencia clásica [donde] las nuevas clases se

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

5 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

pueden crear utilizando las clases existentes como punto de partida” (Troelsen, 2010, p.
219).

A continuación se expone un ejemplo sencillo de la vida real para entender el término y el
concepto.

Se sabe con certeza que un gato es un animal mamífero. Si se requiere representar esta
relación, en una clase C Sharp mediante herencia, una forma muy clara se muestra a
continuación.

Aquí se puede observar lo siguiente:

1) Se cuenta con una clase padre (también llamada base), que es Mamíferos. Ésta
tendrá las características generales de todos los mamíferos (se alimenta de leche
materna durante cierto periodo de tiempo, tiene pelo, etc.).
2) Se cuenta con una clase hija, Gato (también llamada derivada), que tiene las
características específicas del animal gato (es doméstico, es terrestre, come
carne, etcétera).

Si se requiere programar las características generales que serán heredadas por la clase
hija, sólo se programarán en la clase padre y de forma automática, al aplicar el concepto
de herencia, aparecerán en la clase derivada (Gato, en este caso).

A continuación se exponen algunos ejemplos de herencia.

Mamíferos
Gato

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

6 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Tabla 1. Ejemplos de herencia
Clase base* Clase derivada*1
Estudiante EstudianteGraduado
EstudianteNoGraduado
Forma Circulo
Triangulo
Rectangulo
Prestamo PrestamoAutomovil
PrestamoMejoraCasa
PrestamoHipotecario
Empleado Docente
Administrativo
Cuenta CuentaDeCheques
CuentaDeAhorros
Deitel y Deitel, 2007, p. 667.

En esta representación es posible observar lo siguiente:

1) Se cuenta con una clase base o padre que es Estudiante. Esta tendrá las
características generales de todos los estudiantes (acuden a una institución
educativa, tienen una matrícula, etcétera).
2) Se cuenta con dos clases hijas o derivadas que son EstudianteGraduado, que
tiene las características específicas de un estudiante; es decir, ya concluyó los
estudios y adquirió el grado académico correspondiente y Estudiantenograduado
que puede ser de cualquier nivel del sistema educativo correspondiente.

Si se tiene que programar en esta clase las características generales que serán
heredadas por la clase hija, sólo se asignarán en la clase padre, y, de forma automática,
al aplicar el concepto de herencia aparecerán en la derivada (EstudianteGraduado o
Estudiantenograduado según sea el caso).

Se observa que esto es natural de cierta forma porque EstudianteGraduado o
Estudiantenograduado es un Estudiante.

Como puede observarse este término significa que, por el concepto de herencia, la clase
derivada es un ejemplar de la clase base.

1 Se omiten los acentos por cuestiones propias de la programación en las siguientes palabras que
integran la tabla ejemplo de herencia: Círculo, Triángulo, Rectángulo, Préstamo y Automóvil.

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

7 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Puede concluirse que “la herencia en la programación orientada a objetos es el
procedimiento mediante el cual es posible construir nuevas clases extendiendo la
funcionalidad de clases existentes” (Troelsen, 2010, p. 220).

2.1.1. Herencia simple

Como se revisó en el apartado anterior, herencia es un concepto de programación
orientada a objetos, el cual hace posible que una clase derivada reciba atributos (datos y
métodos) de una clase base.

En el marco de la herencia en programación orientada a objetos, pueden observarse dos
casos de herencia C Sharp (Sharp, 2010, p. 262):

1) Una clase padre otorga atributos a una o más clases hija.
2) Varias clases padre otorgan atributos a una o varias clases hija.

El primer caso se conoce como herencia simple, el segundo, como herencia múltiple (el
nombre es dado por el número de clases padre, no por el de clases hija). Esto puede
representarse de la siguiente manera:

Herencia simple Herencia múltiple

Lo anterior es posible en la programación orientada a objetos. Para la programación en C
Sharp no está permitido el manejo de la herencia múltiple, sino sólo la herencia simple;

Nota: El símbolo: Significa que una clase base o padre hereda
atributos a una clase hija. La punta de flecha ♦ indica quién es la clase
padre.

Padre
Hija1 Hija2
Padre1
Hija
Padre2

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

8 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

según lo señalado en la página web de Microsoft (MSDN, 2013 c), “como Java, C# no
admite herencia múltiple, lo que significa que las clases no pueden heredar más de una
clase”.

Lo que sí es posible es tener herencia lineal múltiple. Esto se muestra en la siguiente
figura.

Para fines prácticos, Clase1 es padre de Clase2, y ésta a su vez es padre de Clase3. Es
posible generar cualquier jerarquía de clases (cualquier nivel) en este proceso de
herencia, pero siempre respetando el concepto herencia simple: Sólo puede heredarse de
un padre a una vez. Como se muestra en la imagen anterior, Clase1 es padre de Clase2,
y éste a su vez es padre de Clase3.

El ejemplo anterior es un proceso acumulativo. Clase2 tendrá atributos que recibirá de
Clase1. Clase3 tendrá atributos que recibirá de la Clase2 y Clase1. Esto se repetirá en
todas las clases situadas en los niveles de herencia.

Desde el punto de vista de programación de C Sharp, el concepto de herencia se logra
con el símbolo “:”. A continuación se ofrece un ejemplo.

Se tienen dos clases, Persona y Docente. La primera debe heredar de la segunda.

El enunciado en C Sharp puede representarse así:

Clase1
Clase2
Clase3
Niveles
de
herencia

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

9 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

¿Qué atributos se heredan? En este punto es necesario retomar el concepto de
encapsulamiento de la unidad anterior.

Recuerda que un dato o método miembro puede tener cuatro niveles de alcance:
protegido, público, privado y de alcance al proyecto actual. El nivel de alcance es la
visibilidad que estos miembros tendrán fuera del objeto. En lo que corresponde al caso
expuesto sobre el tema de herencia, es necesario recordar los tres primeros niveles
porque sólo éstos son los que se utilizan para el control de la herencia (Ferguson,
Patterson y Beres, 2005, p. 259).

Si una clase padre tiene miembros (datos y métodos) privados, ninguno de ellos será
heredado a una clase hija; los miembros protegidos sí se heredarán, pero seguirán siendo
protegidos para la clase derivada; los miembros públicos se heredarán y continuarán
siendo públicos.

Las funciones y los datos que se desean heredar deben seguir las reglas de
encapsulamiento.

En el ejemplo se incluirán estas especificaciones:

Persona tendrá los siguientes datos que deberán ser heredados: tipo string el nombre,
char el sexoe int la edad. Se integrará un constructor que recibirá estos tres datos y los
guardará como privados. Se agregará un método llamado información de tipo público, que
mostrará en la pantalla el contenido de los tres datos.

Para implementar la clase es importante recordar que los datos en un objeto siempre
deben ser privados; pero como se desea heredarlos, en este caso serán protegidos.

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

10 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

La clase escrita en C Sharp tendrá la siguiente forma:

El proceso de herencia quedará como sigue:

El constructor que tiene la clase Docente llama al constructor padre con el comando base
y envía los parámetros que recibe, los cuales deben ser los mismos en posición y tipo.

Esto indica que se cumple la siguiente regla en la programación de herencia en lenguaje
C Sharp: “Un constructor a pesar de ser un método público es el único que no se hereda y
necesita ser llamado explícitamente desde la clase hija por la palabra base, con los
argumentos entre paréntesis que se le envían” (Troelsen, 2010, p. 229).

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

11 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

En el programa, es posible utilizar ambos objetos (Persona y Docente) de la siguiente
manera:

Pueden observarse en el programa principal los siguientes puntos:

 Ambos objetos pueden instanciarse de manera similar, a pesar de que la clase
Docente no tiene código interno para la declaración de los datos miembros; pero
al ser una clase heredada de Persona sí los puede utilizar.

 Ambos tienen el método de información(), que muestra el contenido de los datos
miembro, a pesar de que no se implementó en la clase Docente.

Si se ejecuta el programa, la salida será la siguiente:

Nombre: Manuel
Sexo: M
Edad: 34
Nombre: Luisa
Sexo: F
Edad: 30

En la salida del programa se observa que ambos objetos tienen información interna, y
ésta se muestra con el método Informacion(), a pesar de que sólo se ha programado
dicho método para la clase base, pero la clase hija puede utilizarla por herencia.

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

12 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Es posible agregar información al objeto; por ejemplo: si se toma en cuenta que un
docente, además de contar con nombre, sexo y edad, tiene también un número de tarjeta,
puede agregarse un nuevo dato privado llamado tarjeta de tipo entero. Se modificará el
constructor para que llame al de la clase padre y guarde el nuevo dato. Éste también
tendrá un método público con el nombre de informacionTotal(), que mostrará el nombre,
sexo, edad y la nueva información de la tarjeta. Tal como se aprecia en el siguiente
código:

Como se puede ver, el constructor ahora recibe cuatro parámetros, de los cuales tres
envía al constructor padre, el último lo asigna él mismo. Cuando un constructor hijo llama
al padre deben respetarse las siguientes reglas:

1) El número de parámetros enviados y su tipo deberán ser los mismos que los
que recibe el padre (el nombre no importa, sólo el tipo y el número).
2) Después de invocar a su padre actualizará sus propios datos (también
puede realizar otro tipo de procesos, pero siempre después de llamar al
constructor padre).

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

13 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

El programa principal puede modificarse de la siguiente manera:

Al ejecutar este programa, la salida será la siguiente:

Nombre: Manuel
Sexo: M
Edad: 34
Nombre: Luisa
Sexo: F
Edad: 30
Tarjeta: 57

Se puede observar cómo la información se ha ido agregando.

Para finalizar el análisis de esta parte, se recapitula lo revisado respecto al concepto base
de la herencia cuando utiliza el término es-un; en este caso la herencia es factible de ser
utilizada porque el objeto Docente es una “Persona”, finalmente.

A continuación se revisarán las clases abstractas, subtema muy importante para la
herencia porque permite escribir clases que no se deben instanciar.

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

14 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

2.1.2. Clases abstractas

En el mundo real existen clases base que no deben ser instanciadas porque son sólo un
concepto. En una institución educativa no existen las personas como tales; existen
alumnos, directores, profesores, administrativos, etcétera, pero una persona sin una
función no es un concepto aceptable.

Por ejemplo:

La clase Mamífero es una clase abstracta porque en el mundo real no existe un ente
específico llamado mamífero. Es el nombre genérico con el que se clasifica a cierto tipo
de animales; sin embargo, cuando se observa un perro, un gato o un delfín, puede decirse
que son mamíferos; pero por sí mismo el concepto mamífero no indica un animal en
específico; es decir, se refiere a una entidad inexistente en la realidad.

A esas entidades que no deben ser instanciadas porque no representan una realidad son
declaradas como clases abstractas para que el usuario no las instancie y como
consecuencia no las utilice (Ferguson, Patterson y Beres, 2005, p. 267).

Una definición clara de lo que es una clase abstracta se cita en Microsoft (MSDN, 2013b),
en la Guía de programación de C#, el apartado de “Clases y miembros de clase
abstractos y sellados”, donde se señala que “el propósito de una clase abstracta es
proporcionar una definición común de una clase base que múltiples clases derivadas
pueden compartir. Por ejemplo, una biblioteca de clase puede definir una clase abstracta
que se utiliza como parámetro para muchas de sus funciones y solicitar a los
programadores que utilizan esa biblioteca que proporcionen su propia implementación de
la clase mediante la creación de una clase derivada”.

La palabra clave abstract permite crear clases únicamente con propósitos de herencia,
pero estas no se pueden instanciar.

Mamíferos
Gato

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

15 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

En el ejemplo, la clase Persona no debe instanciarse porque es abstracta. Para ello,
simplemente se agrega la palabra abstract antes de class, como puede observarse en el
siguiente código.

En esta ocasión el programa principal mostrará el siguiente error:

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

16 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

No es correcto instanciar el objeto Persona. Si se suprime la línea que tiene el error se
obtendrá lo siguiente:

Al ejecutar el programa es posible observar el siguiente resultado:

Nombre: Luisa
Sexo: F
Edad: 30
Tarjeta: 57

Se debe quitar la instancia de Persona y su llamada p.Informacion().

Una clase abstracta puede tener (aunque no es necesario) métodos miembro abstractos.
Un miembro abstracto puede ser heredado (si es público o protegido), y su finalidad es
indicar que debe existir una implementación, aunque no se dice el cómo hacerla.

Programación .NET II
Unidad2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

17 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Si se requiere un método abstracto para la clase Persona llamado Identificacion(), este
método no se implementará (programará), sólo indicará que toda clase que herede de él
debe integrar el código para que realice su función.

Un método abstracto tiene la siguiente sintaxis, según el MSDN (2013 b):

public|protected abstract tipo nombre(parametros);

public | protected: significa que los métodos abstractos deben ser públicos o protegidos.
Esto es una consecuencia lógica porque deben de ser heredados, y la clase derivada se
va a encargar de su implementación.

abstract: indica que este método no tendrá código.

tipo: indica el valor de retorno del método correspondiente.

nombre(parametros): indica el nombre de la función. Si no tiene parámetros sólo debe
llevar los paréntesis, en caso contrario se agrega la lista de parámetros.

En C Sharp se codificaría como sigue:

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

18 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

19 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

La clase derivada Docente mostraría el siguiente error:

El subrayado en Docente indica que la clase no ha dado funcionalidad al método
abstracto Identificacion(). Se le otorga funcionalidad de la siguiente manera:

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

20 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

21 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Como se puede ver en el ejemplo, cuando una clase hereda un método abstracto y debe
implementarlo, debe incluirse la palabra reservada override. De esta manera se indica
que el método tendrá código para realizar lo solicitado en esta clase. El programa
principal en este ejemplo tendrá la siguiente implementación:

La ejecución es la siguiente:

Nombre: Luisa
Sexo: F
Edad: 30
Tarjeta: 57
Identificación con tarjeta número: 57

Una clase abstracta puede heredarse por otra abstracta. Significa que ninguna de ellas
puede instanciarse. Si se traslada al mundo real, este principio puede comprenderse en la
siguiente jerarquía de clases:

Perro Tigre Tucán Canario Trucha Sardina
Mamíferos
<<Abstracta>>
Aves
<<Abstracta>>
Peces
<<Abstracta>>
Vertebrados
<<Abstracta>>

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

22 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Al observar esta jerarquía, pueden obtenerse varias conclusiones sobre las distintas
clases:

1) Vertebrados, Mamíferos o Aves no pueden instanciarse.
2) Perro, Tigre, Tucán pueden instanciarse.
3) Un Perro es-un Mamífero y un Perro es-un Vertebrado.
4) Perro y Tigre comparten información. Son mamíferos y son vertebrados.
5) Canario y Trucha comparten información como que son vertebrados.
6) Cada constructor debe llamar, con el comando base, al constructor padre. El padre
llamará al constructor de su padre y así sucesivamente.

Las clases han generado una jerarquía que permiten relacionar objetos que comparten
características similares, y separar objetos que no lo hacen.

Surge aquí una pregunta: ¿si la clase Vertebrados tiene un método abstracto, qué
debe hacer Mamíferos cuando herede este método?

Tiene dos opciones:

1) Volverla a declarar como método abstracto; esto se logra volviendo a escribirla tal
y como fue definida en la clase base, sin codificación. El codificarla será trabajo de
la siguiente clase en la jerarquía de la herencia.

2) Sobreescribirla para darle funcionalidad, como se indicó en el ejemplo de
Persona-Docente.

Puede concluirse que en un sistema jerárquico de herencia lineal no existe ninguna
restricción sobre el número de niveles que pueden agregarse.

2.1.3. Clases selladas

Cierto, en la herencia lineal no existe restricción sobre el número de niveles que pueden
agregarse, pero puede ser conveniente detener esta derivación por la naturaleza del
problema.

El modificador sealed se utiliza para impedir la derivación de una clase. Si se especifica
que sealed es la clase base de otra clase, se produce un error en tiempo de
compilación; sealed no puede ser tampoco abstracta. El modificador sealed se utiliza,

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

23 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

principalmente, para impedir la derivación no intencionada, pero también permite algunas
optimizaciones en tiempo de ejecución, según se explica en Microsoft (MSDN, 2013a).

Dicho de otra manera, una clase sellada indica que ésta no puede usarse como base en
una jerarquía de herencia, y que debe ser la última en la jerarquía lineal. Es también claro
que una abstracta no puede ser sellada, porque las clases abstractas deben ser derivadas
para implementarse; lo cual contradice los conceptos de clase sellada y clases abstractas.

En el ejemplo de herencia, Persona-Docente, es posible heredar de Docente una nueva
clase llamada Jefe. En algunas instituciones los jefes de departamento deben ser
docentes propuestos de la misma academia; es decir, que pertenezcan a la misma
academia. Un Jefe de departamento es un docente con estas características:

 Tiene asignado un departamento.
 Es responsable de las funciones de varias personas a su cargo.

Antes de implementar la clase sellada, es conveniente hacer la siguiente observación: una
jerarquía de clases no tiene por qué seguir una jerarquía organizacional; son dos
conceptos muy diferentes, la primera indica cómo se desarrollan y comportan objetos
computacionales, la segunda se refiere al comportamiento lógico de una empresa en
cuanto a sus relaciones laborales. Con base en estas consideraciones, la representación
de los objetos se conforma de la siguiente manera:

Persona
<<Abstracta>>
Docente
Jefe
<<Sellada>

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

24 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

La clase Jefe tendrá un dato miembro privado con el nombre de departamento, de tipo
string; éste será recibido en el constructor. El código de esta clase se muestra a
continuación:

Como puede observarse, existen dos indicaciones importantes:

 La palabra sealed antes de class indica que esta clase no puede ser derivada; es
decir, está sellada a la jerarquía de herencia. Algunos autores, en otros
lenguajes, llaman a este concepto clase “Final” porque la instrucción obliga a que
se termine una jerarquía lineal de varios niveles.

 La palabra new indica que el método Informacion() oculta el método
Informacion() de la clase base Docente. El uso de esta instrucción es muy bien
definido en el siguiente texto: “Hay ocasiones en las que puede resultar
interesante usar la herencia únicamente como mecanismo de reutilización de
código pero no necesariamente para reutilizar miembros. Es decir, puede que
interese heredar deuna clase sin que ello implique que su clase hija herede sus
miembros tal cuales sino con ligeras modificaciones” (González, 2004, p. 83).

La ocultación significa que, cuando se invoque a este método, se ejecutará el de la clase
derivada y no el de la clase padre.

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

25 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

El programa principal tendrá el siguiente código:

La ejecución de este programa arrojará el siguiente resultado:

Nombre: Luisa
Sexo: F
Edad: 30
Tarjeta: 57
Identificación con tarjeta número: 57
Nombre: Ángel
Sexo: M
Edad: 38
Departamento: Sistemas

Para concluir este punto, se recuerda que una clase sellada no puede derivarse o
heredar; por lo tanto, después de Jefe no puede haber más herencia.

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

26 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Actividad 1. Herencia

El propósito de esta actividad es que distingas las características de los siguientes tipos
de términos: clases estándares, clases abstractas, clases selladas.

Según lo desarrollado en el Tema 2.1. Herencia en C Sharp, ésta simplifica la
reutilización de código cuando una clase hija recibe los métodos y datos miembro de una
clase padre. En esta actividad identificarás los diferentes usos de clases y los alcances
de cada una de ellas.

1. Elabora un cuadro comparativo de las características de las siguientes clases:
normales, interfaces, abstractas y selladas.

2. Explica en tu cuadro la definición, uso, alcance y características de cada uno de
los tipos clase, que permiten tener una jerarquía de acuerdo a la realidad de los
objetos en el mundo. Agrega ejemplos de cada uno, así como tus propias
conclusiones sobre semejanzas y diferencias entre ellos.

3. Identifica el uso en la vida real de herencia simple, múltiple y simple-múltiple.

4. Sube tu trabajo a la base de datos.

5. Comenta el cuadro comparativo y los ejemplos de tus compañeros(as), al menos
uno de ellos, sobre la definición de los tipos de clases, así como la pertinencia de
los ejemplos. Recuerda que tus comentarios no deben ser agresivos, sino
constructivos.

6. Guarda la actividad con el nombre DPRN2_U2_A1_XXYZ. Sustituye las XX por
las dos primeras letras de tu primer nombre, la Y por tu primer apellido y la Z por
tu segundo apellido.

7. Envía el archivo a tu Facilitador(a) para recibir retroalimentación.

*Consulta la Rúbrica para elaborar el cuadro comparativo que encontrarás en el
archivo Criterios de evaluación de las actividades de la Unidad 2, para conocer los
parámetros de esta actividad.

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

27 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

2.1.4. Interfaces

En los subtemas anteriores se comentó que la herencia múltiple no existe en C Sharp,
pero que ésta puede ser simulada al utilizar Interfaces. ¿Por qué se utiliza el término
“simular”?, porque una interfaz no hereda datos o métodos miembro a la clase que la
implementa, sólo comportamientos; es decir, indica qué, pero no cómo se debe hacer

Trey Nash en su libro Accelerated C# 2010 describe una interfaz como un contrato que
nos permite acordar una serie de funcionalidades en una clase, esto porque una interfaz
en C Sharp “Contiene sólo las firmas de los métodos […], la implementación de ellos se
hace en la clase que implementa la interfaz”, según se menciona en Microsoft (MSDN,
2013 d), en el apartado “Interface (Referencia de C#)”.

En otras palabras, una interfaz es una clase especial que sólo indica qué métodos debe
tener, pero no dice el cómo debe programarse. Por eso una interfaz sólo tiene la firma de
los métodos (es importante recordar que, según se revisó en la Unidad 1, la firma de un
método es su alcance, el tipo de datos que devuelve, su nombre y los parámetros que
recibe).

A continuación se expone lo ya mencionado con el siguiente ejemplo:

Recordarás que en el subtema anterior 2.1.3. Clases selladas, se desarrolló una jerarquía
de clases Persona-Docente-Jefe. En este caso, se requiere crear la herencia de Alumno
que deriva de Persona. El primero tendrá nombre, sexo y edad, pero se necesitan dos
métodos adicionales de tipo string. Un número de control y una carrera de tipo protegido,
esta nueva relación Persona-Alumno genera en la clase Alumno el siguiente código:

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

28 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Aquí se observa la siguiente información:

1) El constructor de la clase derivada Alumno llama a su padre con la instrucción
base.
2) Se está ocultando el método Informacion() de la clase padre por un nuevo método,
para ello se utiliza la palabra reservada new.
3) Se está obligado a darle funcionalidad al método Informacion(), porque en la clase
padre está definida como abstracta (con la palabra reservada abstract), cuya
funcionalidad debe ser escrita en la clase hija.

Para crear la herencia de Alumno que deriva de la clase Persona, se supone la existencia
de otra también derivada de Persona, llamada Movilidad. Una instancia de Movilidad
representará a un alumno con número de control y carrera, pero debe tener también un
campo que represente la institución de procedencia (en los institutos tecnológicos la
movilidad significa que un alumno puede salir de una institución, tomar una o varias
materias en otros tecnológicos y regresar a su institución de origen tantas veces y en
instituciones diferentes como él lo desee); por el contrario, un alumno representa a un

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

29 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

individuo que se encuentra en dicha institución. La codificación de esta clase se muestra a
continuación:

El programa principal tendrá la siguiente codificación:

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

30 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Al ejecutarse se mostrarán los siguientes resultados:

Nombre: Luisa
Sexo: F
Edad: 30
Tarjeta: 57
Identificación con tarjeta número: 57
Nombre: Ángel
Sexo: M
Edad: 38
Departamento: Sistemas
Nombre: Pedro
Sexo: M
Edad: 20
N. Control: 01010202
Carrera: Sistemas
Nombre: Juan
Sexo: M
Edad: 23
N. Control: 00040104
Carrera: Electrónica
Procedencia de: Veracruz

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

31 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Cuando un alumno ingresa a esa institución existe un convenio importante con él. Puede
cambiar en cualquier momento de carrera −esto también es válido con alumnos de
movilidad−, pero el proceso es diferente al que se seguiría en el caso de los primeros,
quienes al cambiar de carrera sólo deben indicar el interés. En el caso de los segundos,
es necesario generar un número de oficio, que debe llevar a la institución de procedencia,
con el siguiente formato: ORI-aaaammdd-numerodecontrol; donde el primer segmento
debe sustituirse por el año, mes y día, respectivamente.

Esta es una situación típica que puede ser representadapor una interfaz. Este Convenio
(como se nombrará a esta interfaz) codificado se muestra a continuación:

A continuación se presenta el problema que se puede representar en el siguiente
diagrama:

Se puede observar que Alumno y Movilidad necesitan de un tipo de herencia múltiple y
que son una Persona, de alguna forma, pero ellos dos no son un convenio. Convenio
sólo indica la forma en que pueden cambiar su carrera, pero no más datos.

Persona
<<Abstracta>>
Docente
Jefe
<<Sellada>
Alumno Movilidad
Convenio
<<Interfaz>>

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

32 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

La primera parte de la explicación, acerca de la herencia múltiple, no es posible de
resolver “C Sharp no soporta la herencia múltiple” como lo indica Trey Nash en su libro
Accelerated C# (2010, p. 92): “En C #, una clase sólo puede tener una clase base, para
los procesos de herencia”.

Pero C Sharp sí permite que una clase reciba información de una o varias interfaces
simultáneamente. Antes de mostrar cómo se codificaría esto, es necesario recordar que
no es una herencia de una interfaz porque este tipo de clases sólo indican lo que se debe
hacer (convenios o protocolos), pero no dicen cómo se debe hacer.

La primera es una clase (Persona) y se considera herencia; la segunda es una interfaz
(Convenio) y no es herencia, sino funcionalidades que deben realizar ambas clases,
Alumno y Movilidad. Una clase puede recibir indicaciones de funcionalidad de una o
varias interfaces, para esto no existe un límite como en el caso de la herencia simple
obligatoria.

En el ejemplo planteado se deben agregar dos métodos que describan la funcionalidad de
cambio de carrera. En el caso de la clase Alumno el método tiene la siguiente
codificación:

El método de cambiarCarrera(), de la clase Movilidad, además de tener otra codificación
necesita agregar un dato privado llamado oficio, de tipo string.

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

33 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

En el caso de Movilidad, el método informacion() debe agregar el siguiente código:

El programa principal quedará así:

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

34 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

La salida de este código es la siguiente:

Nombre: Juan
Sexo: M

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

35 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Edad: 23
N. Control: 00040104
Carrera: Mecatrónica
Procedencia de: Veracruz
Cambio de carrera con el oficio: ORI-2013511-00040104

Para concluir este tema, se recapitulan los siguientes puntos:

 Las interfaces permiten definir características de comportamiento o capacidades,
que se aplican a las clases sin tener en cuenta su jerarquía. Desde un punto de
vista conceptual, “las interfaces son contratos entre dos trozos de código distintos”
(Archer, 2010, p. 151). Así, aunque dos clases implementen la misma interfaz,
esto no significa que tenga alguna jerarquía.

 Cuando se tiene definida una interfaz y una clase la toma para dar funcionalidad al
término correcto en el que la clase implementa la interfaz, aunque algunos autores
utilizan como sinónimo la clase heredada de la interfaz, esto conceptualmente no
es cierto (Archer, 2010, p. 152).

 Dado que las interfaces definen un contrato, cualquier clase que implemente una
interfaz tiene que definir todos y cada uno de los métodos, de lo contrario el código
no se compilará (Archer, 2010, p. 153). En otras palabras, si una interfaz propone
cinco métodos, la clase que implemente debe implementar esos cinco métodos o
el programa no se ejecutará.

 Mediante la utilización de interfaces se pueden implementar características de
comportamiento múltiples en una única clase. En C#, una clase puede derivar de
una clase única, pero puede implementar tantas interfaces como necesite (Archer,
2010, pp. 155-156).

Ahora que has concluido el primer tema, realiza las actividades de aprendizaje.

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

36 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Actividad 2. Herencia mediante C Sharp

El propósito de la actividad es que soluciones un problema en donde sea necesario
desarrollar una jerarquía de herencia, y que utilices las instrucciones de C Sharp.

Para el desarrollo de la actividad, tu Facilitador(a) te hará llegar un problema respecto a
un diseño de herencia, en el cual realizarás los siguientes pasos:

1. Construye una clase abstracta.

2. Integra un constructor y métodos abstractos.

3. Construye clases con ciertas características de herencia.

4. Otorga funcionalidad.

5. Construye la interfaz requerida.

6. Integra un archivo de texto en el cual muestres las capturas de pantalla de cada
uno de los pasos de este proceso.

7. Una vez realizado tu programa, empaca todo tu proyecto en un archivo .zip;
incluye el archivo de texto con las capturas de pantalla del procedimiento
realizado.

8. Guarda la actividad con el nombre DPRN2_U2_A2_XXYZ. Sustituye las XX por
las dos primeras letras de tu primer nombre, la Y por tu primer apellido y la Z por
tu segundo apellido.

9. Envía el archivo a tu Facilitador(a) mediante la herramienta Tareas para recibir
retroalimentación.

*No olvides consultar el documento Criterios de evaluación de las actividades de la
Unidad 2, para conocer los parámetros.

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

37 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

2.2. Polimorfismo en C Sharp

Como ya se dijo, uno de los pilares fundamentales de la programación orientada a objetos
es la herencia; muchos autores afirman que el segundo es el polimorfismo (Troelsen,
2010) que, como veremos en este apartado, es en gran parte una consecuencia de la
primera.

Como introducción al concepto de polimorfismo, se propone analizar el caso de herencia
propuesto en el siguiente diagrama, donde se simula la serie de cuentas que existen en
un banco.

Esta estructura de herencia es muy fácil de entender. Ambas (DeAhorros e Inversiones),
al heredar de la clase abstracta Cuenta, tienen la obligación de implementar métodos
abstractos: Deposito() y Retiro().

No es lo mismos retirar de clase DeAhorros que de Inversiones. De la primera puede
retirarse en cualquier momento, pero de la segunda sólo se puede hacer en ciertos
momentos específicos; aunque en ninguna se puede retirar una cantidad mayor al saldo
que contengan.

Supón que el banco promociona una nueva clase de cuenta llamada Maestra, similar a la
de ahorros, pero que por proporcionar un mayor interés cobra una pequeña comisión
adicional por realizar retiros; los depósitos están condicionados, deben tener un monto
mínimo para aceptarlos. De primera instancia es posible proponer la siguiente jerarquía
Clase
Cuenta<<Abstract>>
Métodos
<<Abstract>>Deposito()
<<Abstract>>Retiro()
Clase
DeAhorros
Clase
Inversiones

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

38 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

de herencia, donde se toma como clase base DeAhorros y de ella deriva Maestra. Esto
se observa a continuación:

De este problema surgen las siguientes consideraciones y una pregunta fundamental:

1) La clase DeAhorro, al heredar de Cuenta, debe implementar los métodos
Deposito() y Retiro(), porque no es abstracta, sino una definida.
2) La clase Maestra, al heredar de DeAhorro, recibirá los métodos implementados
de Deposito() y Retiro(); pero no le sirven por tener condiciones diferentes, por
ello deberá cambiarlos. ¿Cómo puede hacerlo?

El cambio puede realizarse en función de tres soluciones diferentes:

 Ocultar los métodos del padre (esto se revisó en el subtema 2.1.3. Clases
selladas). Al utilizar la palabra reservada new antes de la nueva definición del
método, se ocultará el de su padre y quedará en función el método de clase
derivada.
 Al cambiar el tipo de parámetros que reciba el método, la clase derivada tendrá
dos métodos: el que hereda de su padre y el suyo propio, un caso de
Clase
Cuenta
<<Abstract>>
Métodos
<<Abstract>>Deposito()
<<Abstract>>Retiro()
Clase
DeAhorros
Clase
Inversiones
Clase
Maestra

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

39 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

sobrecarga. En cualquier momento, la clase derivada podrá hacer uso de ambos
métodos sólo con cambiar los parámetros con los que se invoque.
 Al cambiar el tipo de parámetros que reciba el método, la clase derivada tendrá
dos métodos: el que hereda de su padre y el suyo propio, lo que también deriva
en un caso de polimorfismo.

Según Deitel y Deitel (2007), un método polimórfico o polimorfo se define como una
función que tiene la capacidad de responder al mismo nombre con diferente operatividad
en función de los parámetros utilizados en su invocación.

En la siguiente sección se estudiará el uso del polimorfismo en C Sharp.

2.2.1. Métodos polimórficos

La palabra polimórfico proviene del griego poly (πολύς): mucho, numeroso, frecuente; y de
morpho (μορφος): que tiene una forma determinada (Universidad de Salamanca, 2011).
Es decir, polimórfico significa que “posee varias formas diferentes” (Troelsen, 2010, p.
235).

Desde el punto de vista de programación, un método polimórfico significa una función que
tiene el mismo nombre, pero diferente tipo de parámetros y funcionalidad

Este es un concepto fundamental en la programación orientada a objetos, y en general
existen tres tipos en C Sharp:

 De sobrecarga o sobrecarga (Unidad I. Desarrollo de objetos en la plataforma.
NET).
 Paramétrico.
 De inclusión.

Polimorfismo paramétrico

Para entender el polimorfismo paramétrico se explica cómo hacer métodos polimórficos
en una clase sin herencia.

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

40 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Se requiere desarrollar una clase llamada perímetro, ésta tendrá varios métodos que
permitirán calcular el derredor de las siguientes figuras irregulares.

Se conoce:

L1, L2 y L3
Se conoce:

L1, L2, L3 y L4
Se conoce:

L1, L2, L3, L4 y L5
Se conoce:

L1, L2, L3, L4, L5 y L6

Esta clase tendrá cuatro métodos que recibirán:

 La primera, tres parámetros de tipo double y devolverá el perímetro.
 La segunda, cuatro parámetros de tipo double y devolverá el perímetro; así
sucesivamente.
 Todos los resultados regresarán de tipo double.
 Todos los métodos se llamarán CalculaPerimetro().

La codificación es la siguiente.

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

41 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Puede decirse que el método CalculaPerimetro() es polimórfico paramétrico, porque
cambia el número de parámetros, pero conserva la misma firma (nombre
calculaPerimetro, nivel de ocultamiento public y valor de retorno double) (Sharp, 2010).

El uso es muy sencillo. Si se desea calcular el perímetro de un triángulo, se llama al
método con tres parámetros; si lo que se desea calcular es el perímetro de un pentágono,
se envía al mismo método cinco parámetros.

Esto puede observarse en el programa principal.

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

42 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

La ejecución del programa muestra el siguiente resultado:

Perímetro de un triángulo: 11.3
Perímetro de un cuadrángulo: 10.6
Perímetro de un pentágono: 18.8
Perímetro de un hexágono: 18.6

El método CalculaPerimetro() es un método polimórfico porque existen cuatro métodos
parecidos y sólo son diferentes en el número de parámetros. El anterior fue un ejemplo de
polimorfismo paramétrico

A continuación se analiza un problema de herencia donde será posible observar la utilidad
del polimorfismo paramétrico.

Se requiere crear una clase llamada: EcuacionLineal, que permitirá calcular la expresión:

y = a x + b

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

43 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Tendrá un método llamado evalua(), que recibirá como parámetro “a”, “b” y “x”, y
regresará el valor de “y”. El código se muestra a continuación:

Se definirá una nueva clase llamada, EcuacionCuadratica, con el método evalua(), que
recibirá como parámetros “a”, “b”, “c” y “x”, y devolverá el valor de “y”, según la siguiente
relación:

y = a x2 + b x + c

Esta clase será derivada de la anterior. Finalmente, se creará una clase llamada
EvaluaEcuaciones que heredará las anteriores y permitirá evaluar ecuaciones
cuadráticas y lineales. Esto puede observarse en el siguiente diagrama de herencia:

Clase
EcuacionLineal
Clase
EcuacionCuadratica
Clase
EvaluaEcuaciones

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

44 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

EcuacionCuadratica se muestra a continuación:

EvaluaEcuaciones tendrá la siguiente definición:

Se obtiene una clase que permitirá evaluar las siguientes expresiones:

y = 3 x + 5

Para x=3

y = 4 x2 – 4 x + 3

Para x=3.3

El programa principal tiene la siguiente definición:

Al ejecutar el programa se mostrará la siguiente salida:

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

45 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Ec. Lineal: y=14
Ec. Cuadrática: y=33.36

Como pudo observarse, la clase EvaluaEcuaciones tiene dos métodos polimórficos por
herencia; éste es uno de los usos del polimorfismo. Cuando una clase hereda de otra y
tienen los mismos métodos, pero sus parámetros son diferentes en número, lo que hace
la clase derivada es acumular los métodos.

Para concluir, es necesario recordarlos siguientespuntos:

1) Un método está sobrecargado cuando tiene el mismo número de parámetros, pero
de diferente tipo.
2) Un método es polimórfico cuando tiene diferente número de parámetros sin
importar si son del mismo o de diferente tipo.

En ambos casos los métodos deben tener el mismo nombre, sin importar el tipo de
información que devuelven.

Polimorfismo de inclusión

Según el MSDN (2013 i), “A través de la herencia, una clase puede utilizarse como su
propio tipo o como cualquier tipo de una clase padre”. Cuando un objeto se utiliza como
un tipo que no es ella misma sino de una clase padre, se tiene un polimorfismo a nivel
clase. Este concepto será más fácil de entender con el ejemplo que se expone a
continuación.

Una clase abstracta, llamada Figura, tendrá dos métodos miembro, Perimetro() y
Area(), ambos abstractos. Esta clase tendrá un constructor que recibirá un valor de tipo
doble y lo guardará en un dato miembro protegido. Se heredará a una clase hija llamada
Circulo, que recibirá en su constructor el radio e implementará los métodos: Perimetro()
y Area(), que calcularán el perímetro y el área del círculo. El diagrama de herencia se
observa a continuación.

<<Abstract>>
Figura
Clase
Circulo

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

46 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

La implementación de la clase abstracta puede observarse a continuación:

La clase derivada círculo será definida así.

Se observa un ejemplo de polimorfismo, a nivel objeto, en el programa principal:

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

47 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Si se ejecuta el programa la salida será la siguiente:

28.2744
63.6174

Lo anterior es un ejemplo de polimorfismo a nivel objeto (también llamado de inclusión,
redefinición o subtipado) (Troelsen, 2010).

Es posible hacer polimorfismo a nivel objeto desde cualquier nivel de herencia. Por
ejemplo, si se cuenta con la siguiente jerarquía.

Es válido hacer lo siguiente:

Persona p = new Docente();

Persona presenta polimorfismo a nivel objeto como la clase Docente. Y si se solicitan, los
métodos que se pueden utilizar en la instancia p, serán los métodos de Docente.

Lo contrario no es válido.
Clase
Persona
Clase
Docente

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

48 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Docente d = new Persona();

Este tipo de polimorfismo no puede realizarse, no está permitido en C Sharp ni en otros
lenguajes como Java.

¿Cuál es su uso? Son dos, principalmente:

1) Es posible instanciar clases abstractas (las cuales se caracterizan por no ser
instanciada), de esta manera se logra un mayor grado de generalización. En el
último ejemplo se utiliza una Figura que se comporta como un círculo.
2) Es posible utilizar métodos que apliquen objetos polimórficos para que las
funciones sean lo más genéricas posibles. Esto se explicará en el siguiente
subtema.

2.2.2. Métodos genéricos

El mayor grado de polimorfismo se logra con los métodos genéricos (la máxima
representación del polimorfismo para un lenguaje orientado a objetos), porque
representan el nombre de una función y un grupo de parámetros de los que no se conoce
el tipo.

Un método genérico se declara con parámetros de tipo en lugar de los primitivos (int, float,
char, etcétera) u objetos (MSDN, 2013 f).

Pero ¿qué es un parámetro de tipo? Esto se explica con el siguiente ejemplo.

Este es un método definido de manera tradicional:

Se observa que sus parámetros son dos variables de tipo primitivo int, los cuales se
utilizan como parte de los procesos dentro del método.

Un parámetro tipo es un símbolo que se puede definir y utilizar como una variable, y
adquiere su valor definitivo en el momento en que se utiliza el método, tal como se

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

49 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

muestra en el siguiente ejemplo. Una clase, llamada ClaseGenerica, recibe dos
parámetros mediante un método, los guarda en la clase y muestra el par de parámetros
recibidos. Tal como se ilustra a continuación:

Al inicio de la clase se observa la definición <T1, T2>, en la que se muestra que se
utilizarán dos parámetros tipo; son genéricos porque pueden ser cualquier tipo que se
necesiten en el momento de la implementación. A lo largo de todo el código se utilizaron
estos parámetros.

En el siguiente ejemplo se requiere guardar un par de datos formado por un número
entero y un nombre de persona; lo cual se logra de la siguiente manera:

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

50 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Si se ejecuta el programa, la salida será la siguiente:

(1, MANUEL)

En el momento de la instanciación se utiliza la definición <int, string>, donde se indica el
tipo de valor que se necesita. Ahora se integrará un nuevo uso pero formado por dos
datos string, para guardar el nombre y apellido. Esto se definirá de la siguiente manera:

Si se ejecuta esta nueva versión la salida será la siguiente:

(JUAN,LOPEZ).

Como puede observarse, sólo se cambia la definición del tipo al momento de instanciarse
la clase, en este caso <string, string>. Se logró una clase sobrecargada de forma infinita,
porque se integraron métodos que siempre reciben dos parámetros del tipo que se
necesita.

El polimorfismo, a través de métodos genéricos, permite tener una gran cantidad de
métodos diferentes (polimórficos y sobrecargados), que hacen posible resolver problemas
de funcionalidad similar utilizando una misma firma.

Los métodos genéricos son una interesante herramienta que resulta muy útil en la
construcción de librerías reutilizables.

Actividad 3. Métodos polimórficos

Esta actividad tiene como propósito que identifiques los usos de polimorfismo de
métodos mediante ejemplos de uso. La actividad es colaborativa, por lo que tu
Facilitador(a) te asignará un número de equipo para trabajar.

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

51 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Realiza las siguientes actividades junto con tu equipo de trabajo:

1. Menciona un mínimo de tres ejemplos donde sean de utilidad los métodos
polimórficos. Recurre a problemas que se hayan presentado en alguna de tus
asignaturas anteriores, problemas que observes en aplicaciones reales o
algunos que tú propongas, en los cuales pueda plantearse un polimorfismo
como solución.

Para el desarrollo de este paso es necesario que se establezca comunicación a
través del Foro general de la asignatura, donde tu Facilitador(a) te hará llegar las
indicaciones necesarias sobre el trabajo, conformarás el equipo y llegarás a
acuerdos con tus compañeros(as).

2. Consulta la Rúbrica de participación en foros, que se encuentra disponible en la
sección Material de apoyo.

Al ingresar al foro:

3. Comenta de manera individual un ejemplo que hayan investigado al interior del
equipo.

4. El representante del equipo deberá ingresar al foro pata compartir la
justificación y elejemplo que, consideren, aporta mayores elementos sobre el
tema de polimorfismo y la solución de problemas.

5. Una vez que compartan su aportación, revisa y comenta la participación de al
menos dos compañeros(as), la pertinencia de los ejemplos expuestos, tus
propias experiencias, conocimiento y la aportación que te dejan las
participaciones en el foro.

6. Con base en las aportaciones de tus compañeros(as), elabora conclusiones
individuales y deja tu evidencia en el foro.

*No olvides, consultar el documento Criterios de evaluación de las actividades de la
Unidad 2, para conocer los parámetros.

2.3. Sobreescritura en C Sharp

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

52 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

En este tema se revisará el concepto de sobreescritura. Se dice que una clase hija
sobreescribe un método de la clase padre cuando lo define con las mismas características
(nombre, número y tipo de argumentos) que el de la superclase. En ese caso, el método
al que se tiene acceso es al último, el que redefinió al primero.

Para decirlo de una forma simple, “una sobreescritura es la capacidad que tienen las
clases derivadas para cambiar la funcionalidad que han heredado de sus clases padre,
mediante la modificación del código que tiene en su definición” (Griffiths, 2010, p. 112) (.

Existen dos formas de realizar una sobreescritura en C Sharp: mediante los indicadores
virtual y override. En ambos casos, la idea es cambiar la funcionalidad de un método
previamente escrito dentro de una clase padre.

La sobreescritura, junto con la característica de polimorfismo, son dos herramientas que
permiten ajustar los objetos para que representen de una manera más fiel el mundo real.

2.3.1. Modificador virtual

Como se recordará, la herencia permite definir métodos que serán enviados a las clases
derivadas. Lo que ahora se explicará es que mediante el modificador virtual, además de
definir los métodos que se enviarán a las clases derivadas, es posible cambiar dicha
definición en la clase hija; para ello, la definición de dicho método en la clase padre
necesita estar precedida con la palabra reservada virtual. Este tipo de métodos se llama
virtual, y Microsoft lo define como: “La palabra clave virtual se utiliza para modificar un
método y permite reemplazar a cualquiera de estos en una clase derivada” (MSDN, 2013
g).

Según el MSDN (2013 g), la sintaxis que se usa para definirlos es la siguiente:

virtual <tipoDevuelto> <nombreMétodo>(<parámetros>)
{
<código>
}

Cuando se define un método como virtual, también se asumen varios conceptos
importantes:

1) El método debe ser modificado por cualquier clase que lo herede. No puede ser
tomado tal y como se declara.

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

53 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

2) Se controla la reutilización, se limita lo que se desea y lo que no debe ser
modificado.

2.3.2. Modificador override

El modificador virtual, visto en el tema anterior, trabaja a la par con el modificador
override. De esta manera, es posible decir qué métodos pueden ser sobreescritos y cuál
es el código con el que se sobreescriben.

Si en alguna clase hija se requiere dar una nueva definición del <código> del método,
simplemente se volvería a definir, pero sustituyendo la palabra reservada virtual por
override. Es decir, se utilizaría la siguiente sintaxis (MSDN, 2013 h):

override <tipoDevuelto> <nombreMétodo>(<parámetros>)
{
<nuevoCódigo>
}

Es importante reafirmar que sólo puede cambiarse el código de un método en su clase
hija si en la clase padre el método fue definido como virtual. En caso contrario, el
compilador mostrará un error al intentar redefinirlo.

En el siguiente ejemplo se observará el uso del modificador override.

En una clase llamada Dimensiones se definirá una constante PI, que contendrá el valor
de 3.1416 y dos variables protegidas de tipo doublé, “x” y “y”. Esta clase tendrá un
método virtual que devuelva un valor double llamado Area(), que calculará el área de un
cuadrado.

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

54 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Se crea una clase llamada Círculo que hereda de dimensiones y sobreescribe el método
Área de la clase dimensiones. Este código se muestra a continuación:

Se crea una clase llamada Esfera que hereda dimensiones y sobreescribe el método
Área de la clase dimensiones. Este código se puede analizar a continuación:

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

55 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Se crea una clase llamada Cilindro que herede de dimensiones y sobreescriba el método
virtual Área de la clase dimensiones. El código es el siguiente:

El programa principal muestra el uso de las clases virtuales:

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

56 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

Cuando el programa se ejecuta muestra los siguientes resultados:

Área de un rectángulo: 12.88
Área de un círculo: 36.316896
Área de una esfera: 98.520576
Área de un cilindro: 277.968768

Como puede observarse, la clase virtual se ha redefinido por cada una de las derivadas.

En conclusión puede decirse que la sobreescritura, en la programación orientada a
objetos, es una de las mejores formas de reutilización de código. Desde el inicio de esta
unidad se ha comentado que esta metodología de desarrollo de programas se enfoca en
la reutilización de lo ya realizado en materia de programación. Antes de esta propuesta, la
única solución era que cada programador reescribiera lo que otros habían realizado. Con
esta técnica es posible utilizar de manera completa o parcial (incluso reescribir desde
cero) lo ya realizado por otras clases; todo depende de lo solicitado en el desarrollo de
software y la experiencia del programador.

Autoevaluación

Antes de desarrollar la evidencia de aprendizaje, realiza la autoevaluación con el fin de
realizar un repaso general de la unidad; así como detectar aquellos temas que no has

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

57 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

comprendido en su totalidad y que requieras revisar nuevamente, o bien consultar con
tus compañeros(as) y Facilitador(a).

Para realizar la Autoevaluación, ingresa al listado de actividades en el aula.

Evidencia de aprendizaje. Herencia simple, polimorfismo y
sobreescritura

El propósito de la actividad es que soluciones un problema donde sea necesario
desarrollar clases con métodos virtuales, sobreescritura y las instrucciones de C
Sharp.

Para el desarrollo de la actividad tu Facilitador(a) te hará llegar un problema respecto a
un diseño de herencia en el cual realizarás los siguientes pasos:

1. Construye una clase abstracta.

2. Integra un constructor.

3. Integra métodos virtuales.

4. Construye clases con ciertas características de herencia.

5. Agrega una clase que herede de la clase abstracta.

6. Integra métodos polimórficos

7. Otorga funcionalidad según las especificaciones que te indique tu Facilitador(a).

8. Integra un archivode texto en el cual muestres las capturas de pantalla de cada
uno de los pasos de este proceso.

9. Una vez realizado el programa, empaca todo el proyecto en un archivo .zip;
incluye el archivo de texto con las capturas de pantalla del procedimiento
realizado.

10. Guarda la actividad con el nombre DPRN2_U2_EA_XXYZ. Sustituye las XX por
las dos primeras letras de tu primer nombre, la Y por tu primer apellido y la Z por
tu segundo apellido.

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

58 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

11. Envía el archivo a tu Facilitador(a) para recibir retroalimentación.

*No olvides, consultar el documento Criterios de evaluación de las actividades de la
Unidad 2 para conocer los parámetros de esta actividad.

Cierre de la unidad

En esta unidad se muestra la aplicación de conceptos tales como herencia, polimorfismo y
sobreescritura en lenguaje C Sharp.

La herencia es uno de los pilares de la programación orientada a objetos, porque permite
la reutilización del código y la generación de clases derivadas más especializadas.

En una relación de herencia el primer elemento se llama clase padre o base; el segundo,
clase hija o derivada; este último puede usar los métodos, propiedades y variables de la
primera. También es capaz de modificar los métodos y crear así un nuevo
comportamiento.

El polimorfismo significa que conviven varios métodos con el mismo nombre, pero con
comportamientos diferentes, lo que permite crear distintas funcionalidades.

La sobreescritura es consecuencia de la herencia. Una clase hija puede reescribir,
recodificar, los métodos heredados, darles una funcionalidad diferente para lo que fueron
definidos.

En esta unidad se han revisado conceptos que permiten otorgar mayor funcionalidad a los
programas que realizarás en otras materias y, en un futuro próximo, en la industria. Otros
temas más complejos de la programación orientada a objetos se revisarán en la Unidad 3.
Manipulación de errores y conjuntos de objetos.

Para saber más

En esta sección encontrarás algunos recursos que es recomendable consultes, pues
ofrecen más información acerca de los principales conceptos revisados, tales como
herencia, polimorfismo, interfaces, sobreescritura:

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

59 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

 MSDN. Microsoft Developer Network. (2013). Herencia (Guía de programación de
C#).Recuperado de http://msdn.microsoft.com/es-
es/library/ms173149(v=vs.80).aspx

 MSDN. Microsoft Developer Network. (2013). Clases y miembros de clase
abstractos y sellados (Guía de programación de C#). Recuperado de
http://msdn.microsoft.com/es-es/library/ms173150(v=vs.80).aspx

 En el portal oficial de C Sharp en español de Microsoft encontrarás la explicación
de los conceptos de herencia, polimorfismo e interfaces con varios ejemplos. La
página está en inglés, pero puedes apoyarte en alguna de las diversas
herramientas de traducción para acceder a la información y observar los videos.
Fue desarrollada para la versión de C Sharp 2005, pero es válida para cualquier
versión desde 2008 hasta 2010. El enlace es http://msdn.microsoft.com/en-
us/vstudio//bb798022.aspx

 El libro de José Antonio González Seco, El lenguaje de programación C#, es un
desarrollo libre. Aunque es una versión muy anterior, los conceptos fundamentales
no han cambiado. Se encuentra disponible en la sección Material de apoyo y
también lo puedes obtener de http://dis.um.es/~bmoros/privado/bibliografia/LibroC
Sharp.pdf

Fuentes de consulta

 Archer, T. (2010). A fondo C#, 2010. Madrid: McGraw-Hill.

 Deitel, H. y Deitel, P. (2007). Cómo programar en C Sharp, 2a. ed. Madrid:
Pearson.

 Ferguson J., Patterson B. y Beres J. (2005). La biblia de C Sharp. Madrid: Anaya.

 Griffiths, Ian; Adams, Matthew & Liberty, Jesse (2010). Programming C# 4.0.
Editorial O’Reilly, Estados Unidos

 González J. (2004). Lenguaje de programación en C#. Recuperado de
http://dis.um.es/~bmoros/privado/bibliografia/LibroC Sharp.pdf

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

60 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

 Michaells, M. (2010). Essential C# 4.0. Estados Unidos: Addison Wesley.

 Microsoft Corporation. (1999-2007), C# Language Specification Version 3.0,
Recuperado de download.microsoft.com/.../C
Sharp%20Language%20Specification.doc

 MSDN. Microsoft Developer Network (2013 a). Clases selladas. Recuperado de
http://msdn.microsoft.com/es-MX/library/aa645616%28v=vs.71%29.aspx

 MSDN. Microsoft Developer Network (2013 b). Clases y miembros de clase
abstractos y sellados (Guía de programación de C#). Recuperado de
http://msdn.microsoft.com/es-es/library/ms173150%28v=VS.80%29.aspx

 MSDN. Microsoft Developer Network (2013c). Herencia y clases derivadas (C# y
Java). Recuperado de http://msdn.microsoft.com/es-
es/library/ms228387%28v=VS.80%29.aspx

 __________________________________d. Interface (Referencia de C#).
Recuperado de http://msdn.microsoft.com/es-
es/library/87d83y5b%28v=VS.80%29.aspx

 __________________________________e. Métodos abstractos. Recuperado de
http://msdn.microsoft.com/es-es/library/aa664435%28v=VS.71%29.aspx

 __________________________________f. Métodos genéricos (Guía de
programación de C#). Recuperado de http://msdn.microsoft.com/es-
es/library/twcad0zb(v=vs.80).aspx

 __________________________________g. Virtual (Referencia de C#).
Recuperado de http://msdn.microsoft.com/es-
MX/library/9fkccyh4%28v=vs.80%29.aspx

 __________________________________h. Override (Referencia de C#)
Recuperado de http://msdn.microsoft.com/es-es/library/ebca9ah3(v=vs.80).aspx

 __________________________________i. Polimorfismo en C#
http://msdn.microsoft.com/es-es/library/ebca9ah3(v=vs.80).aspx

 Nash, T. (2010). Accelerated C# 2010. Estados Unidos de América: Apress.

 Sharp, John. (2010). Microsoft Visual C# 2010. Estados Unidos: Microsoft Press.
http://msdn.microsoft.com/es-MX/library/aa645616%28v=vs.71%29.aspx
http://msdn.microsoft.com/es-es/library/ms228387%28v=VS.80%29.aspx
http://msdn.microsoft.com/es-es/library/ms228387%28v=VS.80%29.aspx
http://msdn.microsoft.com/es-es/library/aa664435%28v=VS.71%29.aspx
http://msdn.microsoft.com/es-MX/library/9fkccyh4%28v=vs.80%29.aspx
http://msdn.microsoft.com/es-MX/library/9fkccyh4%28v=vs.80%29.aspx
http://msdn.microsoft.com/es-es/library/ebca9ah3(v=vs.80).aspx
http://msdn.microsoft.com/es-es/library/ebca9ah3(v=vs.80).aspx

Programación .NET II
Unidad 2. Herencia y polilmorfismo en el lenguaje de programación
CSharp

61 División de Ciencias Exactas, Ingeniería y Tecnología | Ingeniería en Desarrollo de Software

 Troelsen, A. (2010). Pro C# 2010 and the .NET 4 Platform. Estados Unidos:
Apress.

 Universidad de Salamanca (2011). Diccionario médico-biológico, histórico y
etimológico. Recuperado de: http://dicciomed.eusal.es/palabra/polimorfismo
http://dicciomed.eusal.es/palabra/polimorfismo