Buenas tarde estimados alumnos y alumnas, les envío el archivo del ejemplo correspondiente al tema de polimorfismo. Léanlo y sigan las instrucciones. Saludos Cordiales.
Vamos a usar una interfaz para aplicar el concepto de
polimorfismo.
Primero creamos un proyecto y paquete Java en Eclipse llamado Polimorfismo_3FGV. Ahora vamos a
crear la clase Figura.java que contendrá el siguiente código:
public class Figura {
private String nombre;
private String color;
public Figura(String nombre) {
super();
this.nombre = nombre;
}
public Figura(String nombre, String
color) {
super();
this.nombre = nombre;
this.color = color;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
Esta va a ser nuestra super clase de la cual heredarán otro tipo de
figuras. Esta clase es simplemente un POJO -POJO son las iniciales de “Plain
Old Java Object”, que puede interpretarse como “Un objeto Java
Plano Antiguo”. Un POJO es una instancia de una clase que no extiende ni
implementa nada en especial. Para los programadores Java sirve para enfatizar
el uso de clases simples y que no dependen de un framework -es un entorno o ambiente de trabajo para desarrollo;
dependiendo del lenguaje normalmente integra componentes que facilitan el
desarrollo de aplicaciones como el soporte de programa, bibliotecas, plantillas
y más.- en especial. - que tiene el nombre y el color de la figura y sus getters y setters y dos
constructores, aunque solo usaremos uno.
Ahora vamos a crear una interfaz. En Eclipse nos vamos a File -> New -> Other -> Interface.
La interfaz se llamará OperacionesFigura.java Esta interfaz contendrá el
siguiente código:
package PolimorfismoExample;
public interface OperacionesFigura {
double calcularArea();
Figura
figura();
}
Básicamente la interfaz tendrá dos métodos. Uno es el método calcularArea()
que devolverá un double con el valor del área de la figura, y otro método que
nos devolverá todo el objeto Figura. Como sabemos cada figura tiene diferente
forma de calcular el área, pero todas tienen esta característica por eso las
figuras que implementen esta interfaz deberán implementar estos dos métodos.
Ahora vamos a crear la clase Triángulo.java. Esta clase va a extender o
heredar de Figura y a implementar la interfaz OperacionesFigura.
package PolimorfismoExample;
public class Triangulo extends Figura implements OperacionesFigura {
private double base;
private Double altura;
public Triangulo(String nombre, String
color, double base, Double altura) {
super(nombre, color);
this.base = base;
this.altura = altura;
}
@Override
public double calcularArea() {
return (base * altura) / 2;
}
public double getBase() {
return base;
}
public void setBase(double base) {
this.base = base;
}
public Double getAltura() {
return altura;
}
public void setAltura(Double
altura) {
this.altura = altura;
}
@Override
public Figura
figura() {
return new Figura(getNombre(), getColor());
}
Triangulo.java tendrá los atributos propios de un triángulo que son base y
altura y además los atributos de la super clase Figura, es decir el nombre y el
color. Aquí al implementar la interfaz tenemos el método calcularArea() que es
base * altura dividido para 2, en el método figura retornamos una nueva Figura
obteniendo el nombre y el color de la super clase. Además tenemos un
constructor con todos los atributos de Triangulo y de la super clase Figura.
Ahora aplicamos lo mismo a otra figura. Creamos la clase Circulo.java:
package PolimorfismoExample;
import static java.lang.Math.*;
public class Circulo extends Figura implements OperacionesFigura {
private double radio;
public Circulo(String nombre, String
color, double radio) {
super(nombre, color);
this.radio = radio;
}
/*
* EJEMPLO DE POLIMORFISMO
*/
@Override
public double calcularArea() {
return PI * pow(radio, 2);
}
public double getRadio() {
return radio;
}
public void setRadio(double radio) {
this.radio = radio;
}
@Override
public Figura
figura() {
return new Figura(getNombre(), getColor());
}
}
Tiene la misma estructura que Triangulo. En este caso tiene como atributo
el radio del círculo y en calcularArea() aplicamos la fórmula del área del
círculo.
Una vez realizado esto vamos a ver cómo ejecutar estos procedimientos. Para
ello creamos la clase CalcularOperacionesFigura.java que contendrá el siguiente
código:
package PolimorfismoExample;
import java.util.ArrayList;
import java.util.List;
public class
CalcularOperacionesFigura {
/**
*
@param args
*/
public static void main(String[] args)
{
OperacionesFigura
fig1 = new Triangulo("Triángulo", "Azul", 15.0, 3.0);
OperacionesFigura
fig2 = new Circulo("Círculo", "Verde", 12.3);
List
lista = new ArrayList();
lista.add(fig1);
lista.add(fig2);
calcularArea(lista);
}
public static void
calcularArea(List listaOperacionesFiguras) {
for (OperacionesFigura
of : listaOperacionesFiguras) {
System.out.println("Nombre:
"
+of.figura().getNombre());
System.out.println("Color: " +of.figura().getColor());
System.out.println("Area = " +of.calcularArea() +" metros
cuadrados");
System.out.println();
}
}
}
Analicemos un poco el código.
En el método main creamos una instancia de la interfaz OperacionesFigura y
le decimos que es igual a new Triángulo y llenamos los valores del constructor:
nombre, color, base, altura. Podemos hacer esto porque Triángulo implementa
OperacionesFigura. Luego hacemos lo propio para Circulo.java y le instanciamos
desde la interfaz.
Hecho esto creamos una lista genérica de la interfaz
List lista, como es genérica solo se puede agregar a
la lista objetos de tipo OperacionesFigura. Hecho eso agregamos a la lista las
dos interfaces que instanciamos anteriormente.
Ahora creamos un método que se llama calcularArea que recibe como parámetro
una lista de interfaz de tipo OperacionesFigura. Luego con un foreach
recorremos nuestra lista y accedemos a los métodos de la interfaz que son
calcularArea() y figura() y de esa manera podemos obtener el área de la Figura
que creamos en la instancia. Nótese que se accede a los métodos de la interfaz
y no de Triangulo o Circulo. De esta manera la interfaz sabrá qué cálculo debe
hacer para obtener el área gracias a la implementación de la interfaz.
