Curso de Java. ¿Que és el Polimorfismo?.
Un buen ejemplo de Polimorfismo lo econtramos en objetos contenedores de cualquier liquido, por ejemplo una botella, un vaso, etc. Según el objeto donde esté contenido, la forma del agua cambiará o se adaptará al recipiente contenedor. En Java pasa algo parecido, el valor retornado de un método varia según el objeto que le invoque. Esto se llama selección en tiempo de ejecución de métodos y es una manifestación de Polimorfismo en Java.
La mejor forma de entender el concepto de polimorfismo en Java es con ejemplos prácticos. Por ejemplo si creamos una clase abstracta con un atributo, un método normal y otro abstracto:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | package polimorfismo; /** * * @author codesitio.com */ abstract class Clase_Abstrac { int num = 10; //Método normal int calcula(){return num*num;} //Método Abstracto abstract int calcula2(); } |
Y dos clases o subclases que hereden de esta clase abstracta. Esta es la primera:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | package polimorfismo; /** * * @author codesitio.com */ public class Clase_A extends Clase_Abstrac{ int numA; //Implementación del método abstracto @Override int calcula2() { numA = calcula(); return numA + 10; } } |
Y esta la segunda:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | package polimorfismo; /** * * @author codesitio.com */ public class Clase_B extends Clase_Abstrac{ int numB; //Implementación del método abstracto @Override int calcula2() { numB = calcula(); return numB + 20; } } |
Si creamos objetos de ambas clases y hacemos la llamada a distintos métodos desde la clase principal que contiene el método main:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | package polimorfismo; /** * * @author codesitio.com */ public class Polimorfismo { public static void main(String[] args) { Clase_A objA = new Clase_A(); Clase_B objB = new Clase_B(); System.out.println("El valor de num es: "+objA.calcula()); System.out.println("El valor de num es: "+objA.calcula2()); System.out.println(); System.out.println("El valor de num es: "+objB.calcula()); System.out.println("El valor de num es: "+objB.calcula2()); } } |
Nos da el siguiente resultado en consola:
Como podemos ver en las llamadas al método calcula() se muestra el resultado que devuelve el método implementado en la clase abstracta, sin embargo en las llamadas al método calcula2() se devuelve el resultado del método implementado en la clase del objeto que le invoca.
Variables de Clase Abstractas y Polimorfismo.
Ya dijimos en la página donde hablamos de Clases Abstractas e Interfaces, que no podemos crear objetos de ninguno de los dos, pero si podemos crear variables de Clase y asignarlas referencias a objetos de Clases que heredan o implementan dichas Clases Abstractas o Interfaces. Veamos un ejemplo de ello, para ello tan solo mostraremos los cambios en la clase principal (método main) y la salida en consola, ya que el resto de clases son iguales:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | package variablesclaseabst; /** * * @author codesitio.com */ public class VariablesClaseAbst { /** * @param args the command line arguments */ public static void main(String[] args) { //Creamos una Variable de Clase_Abstrac Clase_Abstrac varAbst; //Creamos objetos de Clase_A y de Clase_B Clase_A objA = new Clase_A(); Clase_B objB = new Clase_B(); //Asignamos los objetos a la Variable de la clase abstracta varAbst = objA; System.out.println("El valor de num es: "+varAbst.calcula2()); System.out.println(); varAbst = objB; System.out.println("El valor de num es: "+varAbst.calcula2()); } } |
Y en consola tenemos la siguiente salida:
Esta forma de proceder usando variables de Clase y asignarlas después distintos objetos, simplifica el código. Empleamos mismas sentencias, solo cambia el objeto asignado. Si tenemos 2 o 3 objetos no hay mucha diferencia de usar un método u otro, el ahorro aparece cuando se incrementa el número de objetos.
Crear código de esta manera resulta más eficiente, con tiempos de ejecución menores y más fáciles de mantener. El ejemplo muestra una nueva faceta de polimorfismo.