Universidad del Cauca

Facultad de Ingeniería Electrónica y Telecomunicaciones

UNIVERSIDAD DEL CAUCA

FACULTAD DE INGENIERIA ELECTRÓNICA Y TELECOMUNICACIONES
PROGRAMA DE INGENIERÍA ELECTRÓNICA Y TELECOMUNICACIONES

Polimorfismo

OBJETIVO
• Reforzar el concepto de polimorfismo.

DESCRIPCIÓN
El polimorfismo es uno de los 4 pilares de la programación orientada a objetos (POO) junto con la
Abstracción, Encapsulación y Herencia. Para entender que es el polimorfismo es muy importante que
tengáis bastante claro el concepto de la Herencia.

El término "polimorfismo" es una palabra de origen griego que significa "muchas formas". Este
termino se utiliza en la POO para "referirse a la propiedad por la que es posible enviar mensajes
sintácticamente iguales a objetos de tipos distintos". Como esta definición quizás sea algo difícil de
entender, se va a explicarla con un ejemplo de una agencia de viajes, donde se simula el
comportamiento que tendrían diferentes tipos de viajes que ofrece una agencia de viajes. Para este
ejemplo se deben basar en el siguiente diagrama de clases:

_______________________________
- Programa de Ingeniería de Sistemas 1/11
 Universidad del Cauca
Facultad de Ingeniería Electrónica y Telecomunicaciones

NOTA: en este diagrama no se pone los constructores y métodos getter y setter con el fin de que el
diagrama nos quede grande y poco entendible aunque en un buen diagrama de clases deberían aparecer
para respetar el principio de encapsulación de la POO.

En este ejemplo se tiene una clase padre (Viaje) que contiene los atributos y métodos comunes a todos
los viajes y en ella se van a implementar los métodos del comportamiento "genérico" que deben de
tener todos los viajes. La herencia no es más que sacar "factor común" del código que escribimos, así
que los atributos y métodos de la clase Viaje los tendrán también los objetos de las clases
ViajeFamiliar, ViajeIndividual, ViajeIncentivo y ViajeTodoIncludo. Antes de seguir vamos a mostrar el
código de la clase "Viaje" para ver algunas peculiaridades:

public abstract class Viaje {

protected String origen;

protected String destino;
protected int costo;
protected Date fechaSalida;
protected Date fechaLlegada;

// Constructores, getters y setters

public abstract String descripcion();

public String cualquierMetodo() {

return "Cualquier método implementado en la clase base";
}

public String cualquierMetodo2() {

return "Cualquier método2 implementado en la clase base";
}
}

Lo primero que debe de llamar la atención al ver este código es que se utiliza dos veces la palabra
reservada "abstract". Esta palabra nos indica que la clase "Viaje" es una clase abstracta y las clases
abstractas no se pueden instanciar, por tanto nunca se puede hacer un "new Viaje()". También se utiliza
la palabra reservada abstract en el método descripcion. Esto quiere decir que todas las clases hijas de la
clase "Viaje" tienen que tener implementado ese método obligatoriamente. Por tanto con esto que se
acaba de contar y diciendo que la palabra "Polimorfismo" significa "muchas formas", se puede deducir
que la clase "Viaje" es una clase que puede adoptar diferentes formas y en este ejemplo puede adoptar
las formas de ViajeFamiliar, ViajeIndividual, ViajeIncentivo y ViajeTodoIncludo.
Observe cómo se instancian objetos de esta jerarquía de viajes:

Viaje viaje1 = new ViajeFamiliar("Popayán", "Bogotá", 1250000,...);

Viaje viaje2 = new ViajeIncentivo("Popayán", "Medellin", 2100000, ...);
Viaje viaje3 = new ViajeIndividual("Popayán", "San Andres", 4250000, ...);
Viaje viaje4 = new ViajeTodoIncluido("Popayán", "Cartagena", 7350000, ...);
_______________________________
- Programa de Ingeniería de Sistemas 2/11
 Universidad del Cauca
Facultad de Ingeniería Electrónica y Telecomunicaciones

Viaje viaje5 = new Viaje(); //Sería un error

Como se ve un "ViajeFamiliar", un "ViajeIncentivo", un “ViajeIndivicual” y un "ViajeTodoIncluido"

pertenecen a la misma clase padre y por eso se instancian diciendo que es unViaje y son nuevos objetos
de las clases hijas. Por otro lado no se pueden crear objetos de una clase abstracta, El compilador
sacaría error.

Una cosa muy buena que tiene la herencia y el polimorfismo, es que las clases hijas no solo heredan los
métodos (o la implementación de los métodos) de las clases padre, sino que las clases hijas se pueden
especializar. Esto significa que una clase hija puede "redefinir" los métodos de su clase padre; es decir,
que se puede volver a escribir ese método y de ahí la especialización. Para ello, a continuación se ve
partes de la implementación de las clases hijas:

public class ViajeFamiliar extends Viaje {

/**
* Cantidad de integrantes de la familia
*/
private int familia;

//Constructor getters and setters

@Override
public String descripcion() {
return "Viaje para disfrutar con toda tu familia";
}

@Override
public String cualquierMetodo2() {
return "Método implementado en la clase hija viaje familiar";
}
}

public class ViajeIncentivo extends Viaje {

/**
* Empresa que patrocina el viaje al empleado
*/
private String empresa;

//Constructor, getters and setters

@Override
public String descripcion() {
return "Viaje incentivo que te envia la empresa " + empresa;
}

public String cualquierMetodo2() {

return "Método implementado en la clase hija viaje de incentivo";
}

_______________________________
- Programa de Ingeniería de Sistemas 3/11
 Universidad del Cauca
Facultad de Ingeniería Electrónica y Telecomunicaciones

public class ViajeIndividual extends Viaje {

// Constructor

@Override
public String descripcion() {
return "Disfruta tu viaje individual";
}

//No se sobreescribe cualquierMetodo2()

}

public class ViajeTodoIncluido extends Viaje {

// Constructores

@Override
public String descripcion() {
return "Disfruta tu viaje todo incluido";
}

//No se sobreescribe cualquierMetodo2()

}
Como se observa en el código anterior, todas las clases hijas tienen implementado el método
"descripcion()" ya que al tenerlo en la clase padre como método abstracto, es obligatorio que todas las
clases hijas tengan ese método. Por otro lado, se observa en el código que encima del método
"descripcion()" y otros métodos, se tiene la etiqueta "@Override". Esta etiqueta sirve para indicar en el
código que se está "re-escribiendo o especializando" un método que se encuentra en la clase padre y
que se quiere redefinir en la clase hija. Esta etiqueta sólo está en los métodos de las clases hijas que se
tiene definida en la clase padre, por tanto cuando se llame a esos métodos, las clases hijas ejecutaran el
método redefinido en la clase hija y las que no lo hayan redefinido, se ejecutará es método de la clase
padre. En la siguiente imagen se ve cómo se hace estas especializaciones:

_______________________________
- Programa de Ingeniería de Sistemas 4/11
 Universidad del Cauca
Facultad de Ingeniería Electrónica y Telecomunicaciones

_______________________________
- Programa de Ingeniería de Sistemas 5/11
 Universidad del Cauca
Facultad de Ingeniería Electrónica y Telecomunicaciones

Con todo esto ya se pude empezar a ejecutar el programa que simulará el comportamiento de los viajes
que ofrece una agencia de viajes y ver las diferentes formas que adoptan cada uno de los viajes de la
jerarquía. Para ello, se tiene el siguiente código de un Cliente:

public class ClienteMain {

/**
* Arreglo polimórfico de viajes
*/
public static List<Viaje> viajes = new ArrayList();

public static void main(String[] args) {

leerViajes();
mostrarViajes();

/**
* Lee viajes en el arreglo polimórfico
*/
public static void leerViajes() {
try {

Viaje viaje1 = new ViajeFamiliar("Popayán", "Bogotá", 1250000, new

SimpleDateFormat("dd/MM/yyyy").parse("01/05/2019"), new
SimpleDateFormat("dd/MM/yyyy").parse("05/05/2019"), 5);
viajes.add(viaje1);

Viaje viaje2 = new ViajeIncentivo("Popayán", "Medellin", 2100000, new

SimpleDateFormat("dd/MM/yyyy").parse("03/06/2019"), new
SimpleDateFormat("dd/MM/yyyy").parse("09/06/2019"), "Emtel");
viajes.add(viaje2);

_______________________________
- Programa de Ingeniería de Sistemas 6/11
 Universidad del Cauca
Facultad de Ingeniería Electrónica y Telecomunicaciones

Viaje viaje3 = new ViajeIndividual("Popayán", "San Andres", 4250000,

new SimpleDateFormat("dd/MM/yyyy").parse("01/07/2019"), new
SimpleDateFormat("dd/MM/yyyy").parse("12/07/2019"));
viajes.add(viaje3);

Viaje viaje4 = new ViajeTodoIncluido("Popayán", "Cartagena", 7350000,

new SimpleDateFormat("dd/MM/yyyy").parse("01/07/2019"), new
SimpleDateFormat("dd/MM/yyyy").parse("12/07/2019"));
viajes.add(viaje4);

} catch (ParseException ex) {

Logger.getLogger(ClienteMain.class.getName()).log(Level.SEVERE, null,
ex);
}
}

/**
* Recorre e imprime datos del arreglo polimófico
*/
public static void mostrarViajes() {
// En este caso vemos que todos los viajes ejecutan el método
"descripcion()" de forma diferente
// ya que al ser este método abstracto en la clase padre, les forzamos a
las clases hijas a que
// implementen ese método.
for (Viaje viaje : viajes) {
System.out.println("Origen: " + viaje.getOrigen());
System.out.println("Destino: " + viaje.getDestino());
System.out.println("Fecha salida: " + viaje.getFechaSalida());
System.out.println("Fecha llegada: " + viaje.getFechaLlegada());
System.out.println("Costo: " + viaje.getCosto());
System.out.println("Descripción: " + viaje.descripcion());
System.out.println("Cualquier método: " + viaje.cualquierMetodo());
System.out.println("Cualquier método2: " + viaje.cualquierMetodo2());
System.out.println("");
}

}
}

Como se observa se crean objetos de la clase Viaje que adoptan una de las tres formas que pueden
adaptar (ViajeFamiliar, ViajeIndividual, ViajeIncentivo y ViajeTodoIncludo) y se los mete en un
“ArrayList” de objetos de la clase “Viaje”. Ahora al ejecutar este fragmento de código vamos a ver que
todos tienen el mismo comportamiento a la hora de invocar "cualquierMetodo()" , por tanto ejecutarán
el método de la clase padre. No obstante, cada uno de los viajes, al ejecutarse los mismos métodos
("descripcion()" y "cualquierMetodo2()") tienen un comportamiento diferentes:

Origen: Popayán
Destino: Bogotá
Fecha salida: Wed May 01 00:00:00 COT 2019
Fecha llegada: Sun May 05 00:00:00 COT 2019

_______________________________
- Programa de Ingeniería de Sistemas 7/11
 Universidad del Cauca
Facultad de Ingeniería Electrónica y Telecomunicaciones

Costo: 1250000
Descripción: Viaje para disfrutar con toda tu familia
Cualquier método: Cualquier método implementado en la clase base
Cualquier método2: Método implementado en la clase hija viaje familiar

Origen: Popayán
Destino: Medellin
Fecha salida: Mon Jun 03 00:00:00 COT 2019
Fecha llegada: Sun Jun 09 00:00:00 COT 2019
Costo: 2100000
Descripción: Viaje incentivo que te envia la empresa Emtel
Cualquier método: Cualquier método implementado en la clase base
Cualquier método2: Método implementado en la clase hija viaje de incentivo

Origen: Popayán
Destino: San Andres
Fecha salida: Mon Jul 01 00:00:00 COT 2019
Fecha llegada: Fri Jul 12 00:00:00 COT 2019
Costo: 4250000
Descripción: Disfruta tu viaje individual
Cualquier método: Cualquier método implementado en la clase base
Cualquier método2: Cualquier método2 implementado en la clase base

Origen: Popayán
Destino: Cartagena
Fecha salida: Mon Jul 01 00:00:00 COT 2019
Fecha llegada: Fri Jul 12 00:00:00 COT 2019
Costo: 7350000
Descripción: Disfruta tu viaje todo incluido
Cualquier método: Cualquier método implementado en la clase base
Cualquier método2: Cualquier método2 implementado en la clase base

En este caso, se observa que todos los viajes ejecutan el método "descripcion()" de forma diferente ya
que al ser este método abstracto en la clase padre, les forzamos a las clases hijas a que implementen ese
método. Por el contrario al ejecutar el método "cualquierMetodo2()" vemos que los objetos de las
clases ViajeIndividual y ViajeTodoIncluido, utilizan el método implementado en la clase padre y, en
cambio, los objetos de la clase ViajeFamiliar y ViajeIncentivo ejecutan sus métodos "re-implementados
o especializados" que se volvieron a escribir en sus clases.

CONCLUSIONES Y ACLARACIONES
Como se ha visto el polimorfismo es un concepto más avanzado que la herencia y puede ser muy útil a
la hora de jerarquizar y querer dar un patrón de comportamiento común a una serie de objetos que
heredan de la misma clase. En este taller no hemos visto todo lo referente al polimorfismo ya que nos
quedaría ver un concepto un poco más avanzado en Java (y en otros lenguajes también) como son las
"Interface" (clases abstractas puras) de las cuales se espera que el estudiante apropie conocimiento por
su propia cuenta.

Por último es muy probable al principio no se vea mucho sentido al tema del polimorfismo y es normal.
Sólo a base de experiencia se le encuentra sentido al polimorfismo, y como se verá a lo largo del curso,

_______________________________
- Programa de Ingeniería de Sistemas 8/11
 Universidad del Cauca
Facultad de Ingeniería Electrónica y Telecomunicaciones

muchos patrones de diseño hacen uso del polimorfismo para construir aplicaciones flexibles a los
cambios.

¿QUÉ SE DEBE ENTREGAR?

Se puede trabajar en grupos de dos personas.
1. Se debe implementar la aplicación de la agencia de viajes descrita en este taller. A continuación el
diagrama de clases completo.

2. Para determinar si el código está bien implementado se debe ejecutar las pruebas unitarias (Ver el
adjunto ViajeTest.java). A continuación una imagen que muestra la satisfacción de correr las pruebas
unitarias:

_______________________________
- Programa de Ingeniería de Sistemas 9/11
 Universidad del Cauca
Facultad de Ingeniería Electrónica y Telecomunicaciones

3. Finalmente subir la aplicación al repositorio de GitHub (código fuente y pruebas unitarias). Al

docente se debe reportar únicamente la URL de la aplicación para poder clonar la aplicación. Se pueden
basar en este tutorial o cualquier otro. Lo importante es que utilicen los comandos git por consola.

_______________________________
- Programa de Ingeniería de Sistemas 10/11
 Universidad del Cauca
Facultad de Ingeniería Electrónica y Telecomunicaciones

REFERENCIAS

• https://jarroba.com/polimorfismo-en-java-parte-i-con-ejemplos/

_______________________________
- Programa de Ingeniería de Sistemas 11/11