Polimorfismo e Interface

Poli = muchas | morfismo = formas

Recopilando información en internet sobre este tema me hice lio, porque se usa de manera muy equivocada este concepto, hasta se confunde polimorfismo con poliformismo, pero en definitiva no es tan complicado como aparenta. De todas formas veremos los otros conceptos que "definen" al polimorfismo (Interfaces y SobreCarga de métodos).

Poliformismo

El polimorfismo(el auténtico) es la capacidad que trae la POO para usar el mismo método definido en la clase Padre, implementando en las clases hijas para responder de manera autónoma.

Expresado en un ejemplo, creamos una super-clase FiguraGeometrica que como parte de sus comportamientos se define el método calcularArea(). Por otro lado la sub-clase Triangulo "hereda" los atributos y comportamientos y sobreescribe el método calcularArea() para adaptarlo a su modo. Por otro lado mas, la sub-clase Cuadrado hereda de la misma forma que la clase Triangulo y calcula el area de manera diferente. Empezamos con la clase padre y sus 2 hijas:

1. package poliformismo;
2.  
3. public class FiguraGeometrica {
4.     int lado = 0;
5.     int base = 0;
6.     int altura = 0;
7.     public int calcularArea(){
8.         return 0;
9.     }
10. }
11. class Triangulo extends FiguraGeometrica{
12.     public Triangulo(){
13.         this.base = 3;
14.         this.altura = 5;
15.     }
16.     public int calcularArea(){
17.         return base*altura;
18.     }
19. }
20. class Cuadrado extends FiguraGeometrica{
21.     public Cuadrado(){
22.         this.lado = 2;
23.     }
24.     public int calcularArea(){
25.         return lado*lado;
26.     }
27. }

Luego desde otra clase perteneciente al mismo paquete que invoca a ambas:

1. package poliformismo;
2.  
3. public class Principal {
4.     public static void main(String[]args){
5.         Triangulo tri = new Triangulo();
6.         Cuadrado cua = new Cuadrado();
7.         System.out.println("Ejemplo Poliformismo por Dar10.comyr.com ");
8.         System.out.println("El área de un triángulo de ejemplo es: " + tri.calcularArea());
9.         System.out.println("El área de un cuadrado de ejemplo es: " + cua.calcularArea());
10.     }
11. }

El resultado es que Triángulo calcula su área cómo base por altura cuando lo llaman tri.calcularArea() y Cuadrado lo hace lado por lado cuando se declara cua.calcularArea() por consola veremos:

• Ejemplo Poliformismo por Dar10.comyr.com
• El área de un triángulo de ejemplo es: 15
• El área de un cuadrado de ejemplo es: 4

Interfaces

Las Interfaces es igual a una clase, o más bien a una clase abstracta, con atributos y métodos pero estas estan vacias para que quién las implemente las definan. En otras palabras podriamos decir que vienen a ser como un contrato que nuestra clase firma, con esto nos aseguramos que quienes implementen alguna interface si o si tiene que agregar en su cuerpo los métodos que trae la interfaz. Con esto ganamos:

• Obligar a que mis clases utilicen los mismos métodos (nombres y parámetros)
• Relacionar clases que no estén relacionadas por herencia

Implementando Interfaces

Para lograrlo creo un archivo, dentro de una IDE hay un archivo especifico que es "interface", y en lugar de "class" utilizo la palabra reservada interface y en el cuerpo sólo firmo los métodos sin poner su cuerpo.

1. package intefaces;
2.  
3. public interface MiInterface {
4.    
5.     public void calcularArea();
6.     public void calcularPerimetro();
7. }

Ahora llego el momento que mis clases de ejemplo Triangulo y Cuadrado implementen la interface como la palabra reservada implements y su nombre, separadas por comas si hubiera más de una. en la dclaración de clase y obligatoriamente tengo que escribir la firma de los métodos de MiInterface y sobreescribirlo a mi conveniencia.

1. package intefaces;
2.  
3. public class Triangulo implements MiInterface{
4.     int base = 3;
5.     int altura = 5;
6.    
7.     @Override
8.     public void calcularArea() {
9.         System.out.println(base*altura);
10.     }
11.     @Override
12.     public void calcularPerimetro() {      
13.     }
14. }

---

1. package intefaces;
2.  
3. public class Cuadrado implements MiInterface{
4.     int lado = 4;
5.     @Override
6.     public void calcularArea() {
7.         System.out.println(lado*lado);
8.     }
9.     @Override
10.     public void calcularPerimetro() {
11.     }
12. }

Haciendo uso de mi clase principal que contiene el método main, creo los objetos y a su vez estos llaman con el mismo método pero respondiendo de manera distinta, al igual que lo hacian el polimorfismo, y creo que es obvia la confusión, o podría llamarse polimorfismo de herencia y polimorfismo de interface ya que bien basicamente relizan lo mismo.

1. package intefaces;
2.  
3. public class Principal {
4.  
5.     public static void main(String[] args) {
6.         Triangulo tri = new Triangulo();
7.         Cuadrado cua = new Cuadrado();
8.         tri.calcularArea();
9.         cua.calcularArea();
10.     }
11. }

El resultado será:

• 15
• 16