Polimorfismo

Característica de la POO, refiere la capacidad que tienen los objetos de una clase de responder
al mismo mensaje o evento en función de los parámetros utilizados durante su invocación. Es
decir cuando un mismo método toma diferentes comportamientos.

En Java existen varias formas de realizar polimorfismo como la sobreescritura de métodos en

herencia y el uso de interfaces y clases abstractas.

Clase Abstracta
Clase en la que sus métodos no tienen implementación. Sus métodos son declarados como
Abstract. En java se declara de la siguiente forma: public abstract class …

A diferencia de la interface, puede tener métodos abstractos y métodos concretos (Con

implementación).

Interface
Tipo especial de clase en java en la cual sus métodos son públicos y abstractos. No requiere
utilizar en sus métodos el operador Abstract. Su declaración es: public interface … y
generalmente por nemotecnia su nombre inicia con la letra “I”.

Ejemplo de Polimorfismo En Java

http://codejavu.blogspot.com/2013/06/ejemplo-de-polimorfismo-en-java.html

Para este ejemplo vamos a trabajar usando una Interface, una

clase Abstracta y 2 clases Concretas como vemos en el siguiente
diagrama:
Podemos ver que se tiene un árbol de herencia definido, donde la
clase Abstracta Animal implementa la interface IAnimal y al
mismo tiempo es clase Padre de Gato y Perro, los cuales
implementaran no solo los métodos abstractos de Animal sino
también el método comunicarse() de la
interface IAnimal.......en entradas anteriores vimos que una de
las reglas al trabajar con clases abstractas o interfaces es que
todas las clases concretas que desciendan de ellas, están obligadas
a implementar sus métodos......... en este caso veremos como la
clase Animal al ser abstracta no esta obligada a hacerlo, pero sus
hijas si....

Veamos como se codifica el diagrama anterior en Java:

Interface IAnimal.
1
public interface IAnimal {
2
  
3   int valor=5;
4  
5   /**
6    * Método Comunicarse, sera implementado por las clases concretas
7    * que hereden de la clase Animal
   */
8
   public void comunicarse();
9
 
10 }
11
La Interface IAnimal posee el método comunicarse() el cual es
completamente abstracto, evidenciamos que no es necesario
indicarlo mediante la palabra abstract...........De la misma forma
tenemos el atributo valor el cual (al ser declarado en la interface)
se comporta como una Constante, así que nunca va a cambiar (en
la entrada sobre Interfaces indicamos el porqué de estas
propiedades)....

Clase Abstracta Animal.

1
2
3 public abstract class Animal implements IAnimal {
4  
5  private String nombre;
6   
 /**
7   * Constructor de la clase Animal
8   * @param nombre
9   */
10  public Animal (String nombre){
11   this.nombre=nombre;
  System.out.println("Constructor Animal, " +
12     "nombre del animal : "+this.nombre);
13  }
14   
15  /**
16   * Retorna el valor de nombre
  * @return
17   */
18  public String getNombre(){
19   return nombre;
20  }
21  
22   
23  /**
  * Metodo Abstracto tipoAnimal, la implementación depende
24   * de las clases concretas que extiendan la clase Animal
25   */
26  public abstract void tipoAnimal();
27   
28 }
29
30

Como vemos tenemos la clase Abstracta que implementa la

Interface IAnimal pero como mencionamos al principio, esta clase
no esta obligada a implementar el método comunicarse() ya que
también es clase abstracta.

Tenemos el método tipoAnimal() el cual si debe ser declarado

como abstracto, evidenciamos también el atributo nombre el cual
lo declaramos como private y solo accederemos a el en nuestro
árbol de herencia, con el aplicamos un poquito el concepto
de Encapsulación (pero no de la forma ideal, podemos ver una
pequeña definición en la entrada sobre conceptos Básicos).

Clase Gato.
1
2 public class Gato extends Animal{
3  
4    /**
5     * Constructor explicito clase Gato
6     * @param nombre
    */
7     public Gato(String nombre) {
8   super(nombre);//envia el parametro a el constructor de la clase padre
9  System.out.println("Constructor Gato, nombre : "+nombre);
10     }
11  
    public void tipoAnimal() {
12  System.out.println("Tipo Animal : Es un Gato");
13     }
14  
15     public void comunicarse(){
16   System.out.println("Metodo comunicarse : El gato maulla... Miau Miau");
17     }
}
18
19

Clase Perro.
1
2 public class Perro extends Animal{
3   
4   /**
5    * @param nombre
   */
6    public Perro(String nombre) {
7    super(nombre);
8    System.out.println("Constructor perro, nombre : "+nombre);
9  }
10  
11  public void tipoAnimal() {
  System.out.println("Tipo Animal : Es un Perro");
12  }
13   
14  public void comunicarse(){
15   System.out.println("Metodo comunicarse : El perro Ladra... Guau Guau");
16  }
17 }
18

Como vemos las Clases Gato y Perro heredan de la clase

abstracta Animal, por ende implementan el
método tipoAnimal(), y como Animal implementa la
interface IAnimal, entonces tanto Gato como Perro al ser clases
concretas están obligadas a implementar el
método comunicarse()....

En las clases también podemos ver que se utiliza la propiedad

nombre que es enviada al constructor de Animal mediante el
llamado a super(nombre).

Hasta aquí ya tenemos las clases del diagrama, ahora veamos

como relacionarlas mediante una clase principal.

Clase Test.
1
2
3
public class Test {
4
 public static void main (String[] arg){
5
 
6  /**Creamos anim, un objeto Perro de tipo Animal*/
7  Animal anim= new Perro("goliath") ;
8  anim.tipoAnimal();
9  anim.comunicarse();
 System.out.println();
10
   
11  /**Creamos perro, un objeto Perro de tipo Perro*/
12  Perro perro=new Perro("hercules");
13  perro.tipoAnimal();
14  System.out.println();
15    
16  /**Creamos animalPolimorfico, un objeto perro de tipo Animal
  * asignamos una referencia ya existente*/
17  Animal animalPolimorfico=perro;
18  animalPolimorfico.tipoAnimal();
19  System.out.println();
20    
21  /**reasignamos la referencia del objeto anim a el objeto perro
22   * esto es valido ya que ambos son de tipo Perro*/
 perro=(Perro) anim;
23  perro.tipoAnimal();
24  System.out.println();
25   
26  /**Creamos gat, un objeto Gato de tipo Animal*/
27  Animal gat=new Gato("pichi");
28  gat.tipoAnimal();
 gat.comunicarse();
29  System.out.println();
30   
31  /**Creamos cat, un objeto Gato de tipo IAnimal
32   * Para esto aplicamos polimorfismo usando la Interface*/
33  IAnimal cat = new Gato("pitufa");
 cat.comunicarse();
34
35   
 System.out.println("\nConstante en la interfaz Animal : "+IAnimal.valor);
36  }
37 }
38
39
40
Esta clase permite la creación de Objetos Polimorficos donde
vemos que podemos usar las superClases para crear objetos de
sus subClases, de esa forma podemos decir que perro es
un Animal o Gato es un Animal .... Al ejecutar obtenemos.

En este ejemplo creamos diferentes objetos uno a uno para

verificar la aplicación del polimorfismo, pero esto también puede
evidenciarse de otras maneras, por ejemplo podemos crear un
arreglo de tipo Animal y en el almacenar objetos de su árbol de
herencia.... veamos..

Agreguemos a la clase Test el siguiente código...

1 Animal animales[]= { new Perro("simon"),new Perro("paco"),new Gato("mimi")};
2   for(Animal a : animales){
3         a.tipoAnimal();
4   }
  System.out.println();
5

Como mencioné hace un momento, tenemos un arreglo animales

de tipo Animal donde en cada posición almacenamos diferentes
objetos subClases de Animal, así que cuando recorremos el
arreglo podemos acceder a las propiedades del objeto que
corresponda, así como las de su superClase...

Si de pronto quisieramos agregar al arreglo animales un objeto

de tipo Planta, esto nos arrojaría error, ya que planta no debería
hacer parte de la Jerarquía definida para el arreglo con el que
estamos trabajando, en otras palabras porque planta no es
un Animal....

Fuentes
https://www.aprenderaprogramar.com

http://codejavu.blogspot.com/2013/06/ejemplo-de-polimorfismo-en-java.html