26-4-2018

Contenido
Polimorfismo ....................................................................................................................................... 2
Polimorfismo de sobrecarga ........................................................................................................... 2
 Polimorfismo
La palabra polimorfismo proviene del griego y significa que posee varias formas diferentes. Es uno
de los conceptos esenciales de la programación orientada a objetos. Así como la herencia está
relacionada con las clases y su jerarquía, el polimorfismo lo está con los métodos.

En general, hay tres tipos de polimorfismo: el polimorfismo de sobrecarga, el polimorfismo

paramétrico (también llamado polimorfismo de plantillas) y el polimorfismo de inclusión (también
llamado redefinición o subtipado).

Los diferentes tipos de polimorfismo

Trataremos de describir ahora con más precisión estos tipos de polimorfismo, pero te sugerimos
prestar atención, ya que muchas personas suelen confundirse al tratar de comprender las
diferencias existentes entre estos tres tipos.

Polimorfismo de sobrecarga
El polimorfismo de sobrecarga ocurre cuando las funciones del mismo nombre existen, con función
similar, en clases que son completamente independientes unas de otras (estas no tienen que ser
clases secundarias de la clase objeto). Por ejemplo, la clase complex, la clase image y la clase link
pueden todas tener la función display. Esto significa que no necesitamos preocuparnos sobre el tipo
de objeto con el que estamos trabajando si todo lo que deseamos es verlo en la pantalla.

Por lo tanto, el polimorfismo de sobrecarga nos permite definir operadores cuyos comportamientos
varían de acuerdo a los parámetros que se les aplican. Así es posible, por ejemplo, agregar el
operador + y hacer que se comporte de manera distinta cuando está haciendo referencia a una
operación entre dos números enteros (suma) o bien cuando se encuentra entre dos cadenas de
caracteres (concatenación).

Polimorfismo paramétrico
El polimorfismo paramétrico es la capacidad para definir varias funciones utilizando el mismo
nombre, pero usando parámetros diferentes (nombre y/o tipo). El polimorfismo paramétrico
selecciona automáticamente el método correcto a aplicar en función del tipo de datos pasados en
el parámetro.

Por lo tanto, podemos por ejemplo, definir varios métodos homónimos de addition() efectuando
una suma de valores. El método int addition(int,int) devolvería la suma de dos números enteros. Por
su parte, float addition(float, float) devolvería la suma de dos flotantes. En cuanto a char
addition(char, char) daría por resultado la suma de dos caracteres definidos por el autor.

Una signature es el nombre y tipo (estático) que se da a los argumentos de una función. Por esto,
una firma de método determina qué elemento se va a llamar.

Polimorfismo de subtipado

La habilidad para redefinir un método en clases que se hereda de una clase base se llama
especialización. Por lo tanto, se puede llamar un método de objeto sin tener que conocer su tipo
intrínseco: esto es polimorfismo de subtipado. Permite no tomar en cuenta detalles de las clases
especializadas de una familia de objetos, enmascarándolos con una interfaz común (siendo esta la
clase básica).

Imagina un juego de ajedrez con los objetos rey, reina, alfil, caballo, torre y peón, cada uno
heredando el objeto pieza. El método movimiento podría, usando polimorfismo de subtipado, hacer
el movimiento correspondiente de acuerdo a la clase objeto que se llama. Esto permite al programa
realizar el movimiento.de_pieza sin tener que verse conectado con cada tipo de pieza en particular.

Clases abstractas
Las clases abstractas son aquellas que por sí mismas no se pueden identificar con algo 'concreto' (no
existen como tal en el mundo real), pero sí poseen determinadas características que son comunes
en otras clases que pueden ser creadas a partir de ellas.
Para que lo comprendas mejor, un ejemplo de clase abstracta sería una llamada Vehículo: todos
ellos realizan acciones similares (arrancar, acelerar, frenar, etc.), pero sin embargo existen muchos
tipos de vehículos diferentes y que se comportan de forma totalmente distinta (el proceso de
arrancarlos no se realiza siguiendo los mismos pasos, unos tienen que despegar y vuelan como los
aviones, otros se sumergen para desplazarse por debajo del agua como los submarinos, cada uno
de ellos necesita ser frenado de distinto modo...).

Métodos abstractos
Un método abstracto es un método declarado pero no implementado, es decir, es un método del
que solo se escribe su nombre, parámetros y tipo devuelto pero no su código.

Los métodos abstractos se escriben sin llaves {} y con; al final de la declaración.

Por ejemplo:

public abstract area();

Un método se declara como abstracto porque en ese momento (en esa clase) no se conoce cómo
va a ser su implementación.

Por ejemplo: A partir de una clase Polígono se pueden derivar las clases Rectángulo y Triángulo.
Ambas clases derivadas usarán un método área. Podemos declararlo en Figura como abstracto y
dejar que cada clase lo implemente según sus necesidades.

Al incluir el método abstracto en la clase base se obliga a que todas las clases derivadas lo
sobrescriban con el mismo formato utilizado en la declaración.

Si una clase contiene un método abstracto se convierte en clase abstracta y debe ser declarada
como tal.

La forma general de declarar un método abstracto en Java es:

[modificador] abstract tipoDevuelto nombreMetodo([parámetros]);

Supongamos un esquema de herencia que consta de la clase Profesor de la que heredan

ProfesorInterino y ProfesorTitular. Es posible que todo profesor haya de ser o bien ProfesorInterino
o bien ProfesorTitular, es decir, que no vayan a existir instancias de la clase Profesor. Entonces, ¿qué
sentido tendría tener una clase Profesor?

El sentido está en que una superclase permite unificar campos y métodos de las subclases, evitando
la repetición de código y unificando procesos. Ahora bien, una clase de la que no se tiene intención
de crear objetos, sino que únicamente sirve para unificar datos u operaciones de subclases, puede
declararse de forma especial en Java: como clase abstracta. La declaración de que una clase es
abstracta se hace con la sintaxis public abstract class NombreDeLaClase { … }. Por ejemplo public
abstract class Profesor. Cuando utilizamos esta sintaxis, no resulta posible instanciar la clase, es
decir, no resulta posible crear objetos de ese tipo. Sin embargo, sigue funcionando como superclase
de forma similar a como lo haría una superclase “normal”. La diferencia principal radica en que no
se pueden crear objetos de esta clase.

Declarar una clase abstracta es distinto a tener una clase de la que no se crean objetos. En una clase
abstracta, no existe la posibilidad. En una clase normal, existe la posibilidad de crearlos aunque no
lo hagamos. El hecho de que no creemos instancias de una clase no es suficiente para que Java
considere que una clase es abstracta. Para lograr esto hemos de declarar explícitamente la clase
como abstracta mediante la sintaxis que hemos indicado. Si una clase no se declara usando abstract
se cataloga como “clase concreta”. En inglés abstract significa “resumen”, por eso en algunos textos
en castellano a las clases abstractas se les llama resúmenes. Una clase abstracta para Java es una
clase de la que nunca se van a crear instancias: simplemente va a servir como superclase a otras
clases. No se puede usar la palabra clave new aplicada a clases abstractas. En el menú contextual de
la clase en BlueJ simplemente no aparece, y si intentamos crear objetos en el código nos saltará un
error.

A su vez, las clases abstractas suelen contener métodos abstractos: la situación es la misma. Para
que un método se considere abstracto ha de incluir en su signatura la palabra clave abstract.
Además un método abstracto tiene estas peculiaridades:

a) No tiene cuerpo (llaves): sólo consta de signatura con paréntesis.

b) Su signatura termina con un punto y coma.

c) Sólo puede existir dentro de una clase abstracta. De esta forma se evita que haya métodos que
no se puedan ejecutar dentro de clases concretas. Visto de otra manera, si una clase incluye un
método abstracto, forzosamente la clase será una clase abstracta.
d) Los métodos abstractos forzosamente habrán de estar sobreescritos en las subclases. Si una
subclase no implementa un método abstracto de la superclase tiene un método no ejecutable, lo
que la fuerza a ser una subclase abstracta. Para que la subclase sea concreta habrá de implementar
métodos sobreescritos para todos los métodos abstractos de sus superclases.

Un método abstracto para Java es un método que nunca va a ser ejecutado porque no tiene cuerpo.
Simplemente, un método abstracto referencia a otros métodos de las subclases. ¿Qué utilidad tiene
un método abstracto? Podemos ver un método abstracto como una palanca que fuerza dos cosas:
la primera, que no se puedan crear objetos de una clase. La segunda, que todas las subclases
sobreescriban el método declarado como abstracto.

Sintaxis tipo: abstract public/private/protected TipodeRetorno/void ( parámetros … );

Por ejemplo: abstract public void generarNomina (int diasCotizados, boolean plusAntiguedad);

Que un método sea abstracto tiene otra implicación adicional: que podamos invocar el método
abstracto sobre una variable de la superclase que apunta a un objeto de una subclase de modo que
el método que se ejecute sea el correspondiente al tipo dinámico de la variable. En cierta manera,
podríamos verlo como un método sobreescrito para que Java comprenda que debe buscar
dinámicamente el método adecuado según la subclase a la que apunte la variable.

¿Es necesario que una clase que tiene uno o más métodos abstractos se defina como abstracta? Sí,
si declaramos un método abstracto el compilador nos obliga a declarar la clase como abstracta
porque si no lo hiciéramos así tendríamos un método de una clase concreta no ejecutable, y eso no
es admitido por Java.

¿Una clase se puede declarar como abstracta y no contener métodos abstractos? Sí, una clase puede
ser declarada como abstracta y no contener métodos abstractos. En algunos casos la clase abstracta
simplemente sirve para efectuar operaciones comunes a subclases sin necesidad de métodos
abstractos. En otros casos sí se usarán los métodos abstractos para referenciar operaciones en la
clase abstracta al contenido de la sobreescritura en las subclases.

¿Una clase que hereda de una clase abstracta puede ser no

abstracta? Sí, de hecho esta es una de las razones de ser de
las clases abstractas. Una clase abstracta no puede ser
instanciada, pero pueden crearse subclases concretas sobre
la base de una clase abstracta, y crear instancias de estas subclases. Para ello hay que heredar de la
clase abstracta y anular los métodos abstractos, es decir, implementarlos.

Vamos a ver un ejemplo basado en el siguiente esquema:

En este diagrama de clases vemos cómo hemos definido una clase abstracta denominada Profesor.
BlueJ la identifica señalando <<abstract>> en la parte superior del icono de la clase. Sin embargo,
hereda de la clase Persona que no es abstracta, lo cual significa que puede haber instancias de
Persona pero no de Profesor.

El test que hemos diseñado se basa en lo siguiente: ProfesorTitular y ProfesorInterino son

subclases de la clase abstracta Profesor. ListinProfesores sirve para crear un ArrayList de
profesores que pueden ser tanto interinos como titulares y realizar operaciones con esos
conjuntos. El listín se basa en el tipo estático Profesor, pero su contenido dinámico siempre será a
base de instancias de ProfesorTitular o de ProfesorInterino ya que Profesor es una clase abstracta,
no instanciable. En la clase de test creamos profesores interinos y profesores titulares y los vamos
añadiendo a un listín. Posteriormente, invocamos el método imprimirListin, que se basa en los
métodos toString de las subclases y de sus superclases mediante invocaciones sucesivas a super.

Modelado de clases abstractas

Cuando una declaración de método de instancia incluye un modificador abstract, se dice que el
método es un método abstracto. Aunque un método abstracto es también implícitamente un
método virtual, no puede tener el modificador virtual.

Una declaración de método abstracto introduce un nuevo método virtual pero no proporciona una
implementación del método. En cambio, es necesario que las clases derivadas no abstractas
proporcionen su propia implementación mediante el reemplazo del método. Debido a que un
método abstracto no proporciona una implementación real, el cuerpo-del-método de un método
abstracto consiste simplemente en un punto y coma. Las declaraciones de métodos abstractos sólo
se permiten en clases abstractas.

public abstract class Shape

{
public abstract void Paint(Graphics g, Rectangle r);
}
public class Ellipse: Shape
{
public override void Paint(Graphics g, Rectangle r) {
g.DrawEllipse(r);
 }
}
public class Box: Shape
{
public override void Paint(Graphics g, Rectangle r) {
g.DrawRect(r);
}
}
La clase Shape define la noción abstracta de un objeto de forma geométrica que puede dibujarse él
mismo. El método Paint es abstracto porque no existe una implementación predeterminada
significativa. Las clases Ellipse y Box son implementaciones Shape concretas. Ya que estas clases no
son abstractas, son necesarias para reemplazar el método Paint y proporcionar una implementación
real.

Variables, polimórficas (plantillas) definición, uso y aplicaciones

En Java, las variables que contienen objetos son variables polimórficas. El término «polimórfico»
(literalmente: muchas formas) se refiere al hecho de que una misma variable puede contener
objetos de diferentes tipos (del tipo declarado o de cualquier subtipo del tipo declarado). El
polimorfismo aparece en los lenguajes orientados a objetos en numerosos contextos, las variables
polimórficas constituyen justamente un primer ejemplo.

Observemos la manera en que el uso de una variable polimórfica nos ayuda a simplificar nuestro
método listar. El cuerpo de este método es:

for (Elemento elemento : elementos)

elemento.imprimir();

En este método recorremos la lista de elementos (contenida en un ArrayList mediante la variable

elementos), tomamos cada elemento de la lista y luego invocamos su método imprimir.El uso de
herencia en este ejemplo ha eliminado la necesidad de escribir dos ciclos en el método listar. La
herencia evita la duplicación de código no sólo en las clases servidoras sino también en las clases
clientes de aquellas.

public class CD
{

private String title;

private String artist;

private String comment;

CD(String theTitle, String theArtist)

title = theTitle;

artist = theArtist;

comment = " ";

void setComment(String newComment)

{ ... }

String getComment()

{ ... }

void print()

{ ... }

...

public class DVD

private String title;

private String director;

private String comment;

DVD(String theTitle, String theDirector)

title = theTitle;

director = theDirector;
comment = " ";

void setComment(String newComment)

{ ... }

String getComment()

{ ... }

void print()

{ ... }

...

class Database {

private ArrayList<CD> cds;

private ArrayList<DVD> dvds;

...

public void list()

for(CD cd : cds) {

cd.print();

System.out.println(); }

for(DVD dvd : dvds) {

dvd.print();

System.out.println(); }

Reutilización de código

Lo primero que se les viene a la cabeza a los estudiantes (y a muchos profesionales) cuando se les
menciona la reutilización del código es el famoso copiar y pegar al que se han acostumbrado en la
programación estructurada, y de echo muchos lo hacen en poo, lo cual es una de las practicas que
más encarece el desarrollo de software. Como todo en Java, el problema se resuelve con las clases.
Para reutilizar el código creamos nuevas clases pero, en lugar de partir de cero, partimos de clases,
relacionadas con nuestra clase, que han sido ya creadas y depuradas. El truco está en usar las clases
sin ensuciar el código existente.

Una forma de hacer esto es crear objetos de nuestras clases existentes dentro de la nueva clase.
Esto se conoce como composición porque la nueva clase está compuesta de objetos de clases
existentes. Estamos reutilizando la funcionalidad del código, y no la forma.

Otra forma es crear una nueva clase como un tipo de una clase ya existente. Tomamos la forma de
la clase existente y añadimos código a la nueva, sin modificar la clase existente. Esta forma de crear
nuevos objetos se llamada herencia, y lo que hacemos es extender la clase en la que nos basamos
para crear la nueva.

Composición:

Hasta ahora hemos usado la composición de cierta manera, ej. cuando hacemos una interfaz gráfica
de usuario, nuestra clase de interfaz gráfica está compuesta por un frame, unos panel, botones, etc.
todos estos objetos componen el objeto de interfaz gráfica. Es decir que la composición consiste en
poner manejadores de objetos dentro de nuestra clase, estos manejadores de objetos no serán otra
cosa que instancias de las clases en las que nos estamos basando para crear la nueva clase.
 Referencias
Alvarez, M. (2018). Polimorfismo en Programación Orientada a Objetos.
[online] DesarrolloWeb.com. Available at:
https://desarrolloweb.com/articulos/polimorfismo-programacion-orientada-
objetos-concepto.html [Accessed 27 Apr. 2018].
Sites.google.com. (2018). 4.3 interfaces, definición, implementacion de interfaces,
herencia de interfaces - Programcion. [online] Available at:
https://sites.google.com/site/wwwprogramacionorientadacom/43-interfaces-
definicin-implementacion-de-interfaces-herencia-de-interfaces [Accessed 27
Apr. 2018].

El blog de Martini. (2018). POO – Clases Abstractas, Interfaces y Herencia

Múltiple.. [online] Available at:
https://emartini.wordpress.com/2008/09/17/poo-clases-abstractas-interfaces-
y-herencia-multiple/ [Accessed 27 Apr. 2018].
Itslr.edu.mx. (2018). TPM | Tutorial de Programacion Multiplataforma. [online]
Available at: http://itslr.edu.mx/archivos2013/TPM/temas/s2u4.html
[Accessed 27 Apr. 2018].
El blog de Martini. (2018). POO – Clases Abstractas, Interfaces y Herencia
Múltiple.. [online] Available at:
https://emartini.wordpress.com/2008/09/17/poo-clases-abstractas-interfaces-
y-herencia-multiple/ [Accessed 27 Apr. 2018].