Cuando hablamos de polimorfismo en java, nos referimos a que un objeto puede comportarse de diferentes formas dependiendo del contexto.
Además este término, está relacionado con el concepto de herencia y el principio de sustitución en java.
Otra definición sería que se puede utilizar un objeto de una subclase, siempre que el programa espere un objeto de la superclase.
Por otro lado, se dice que las variables objeto en java (que no los datos primitivos). son polimórficas. Es decir, dependiendo del contexto en el que se utilicen, pueden comportarse de una forma u otra.
Para ejemplificar este concepto, vamos a utilizar las dos clases que hemos creado cuando vimos la herencia.
Sin embargo, en este caso, la clase persona no será una clase abstracta. Por este motivo, al no ser una clase abstracta, podremos crear objetos de esa clase persona.
Creando la clase persona.
Esta clase tendrá un constructor y sus métodos getter y setter para establecer y devolver valores.
package objetos;
/* Creamos una clase persona*/
public class Persona {
// Creamos las características de los socios
private String dni; // Atributo dni
private String nombre; // Atributo nombre
private String apellidos; // Atributo apellidos
/* Creamos un constructor
* que nos pida todos los parámetros*/
Persona(String dniSocio,
String nombreSocio, String apellidosSocio){
this.dni = dniSocio;
this.nombre = nombreSocio;
this.apellidos = apellidosSocio;
}
/* Creamos un método que devuelva el DNI*/
public String getDni() {
return dni;
}
/* Creamos un método que establezca el DNI*/
public void setDni(String dni) {
this.dni = dni;
}
/* Creamos un método que devuelva el nombre*/
public String getNombre() {
return nombre;
}
/* Creamos un método que establezca el nombre*/
public void setNombre(String nombre) {
this.nombre = nombre;
}
/* Creamos un método que devuelva los apellidos*/
public String getApellidos() {
return apellidos;
}
/* Creamos un método que
* establezca los apellidos*/
public void setApellidos(String apellidos) {
this.apellidos = apellidos;
}
}
Creando la clase socio como herencia.
Aunque puede haber varios constructores, en este caso nos vamos a quedar con uno único pasándole todos los parámetros.
ackage objetos;
/* En este caso utilizamos la palabra reservada extends
* para indicar que la clase Socio, hereda de la clase Persona*/
public class Socio extends Persona {
/* Creamos un atributo para el socio. Este atributo será
* accesible sólo desde esta clase.*/
private int idSocio;
/* Creamos un constructor y le pasamos por parámetros
* los datos del socio*/
Socio(String dniSocio, String nombreSocio,
String apellidosSocio, int id){
/* Llamamos al método super y le pasamos por parámetro
* los argumentos que pide la clase padre llamada persona*/
super(dniSocio, nombreSocio, apellidosSocio);
this.idSocio=id;
}
/* Creamos un método get para devolver el id del socio*/
public int getIdSocio() {
return idSocio;
}
/* Creamos un método set para establecer el id de socio.*/
public void setIdSocio(int idSocio) {
this.idSocio = idSocio;
}
}
Generando polimorfismo en java entre objetos.
En este caso en el método main de la clase principal, crearemos varios objetos tanto de la clase persona, como de la clase socio. Después los guardaremos en un array de objetos de tipo persona con 6 elementos.
package objetos;
public class Principal {
public static void main(String[] args) {
/* Creamos un array de tipo persona para
* almacenar objetos de tipo persona.*/
Persona[] personas=new Persona[6];
/* Creamos 3 objetos de tipo persona. y los agregamos
* al array de personas*/
personas[0] = new Persona("12345678X","Carlos","Martínez");
personas[1] = new Persona("85245678T","Marta","Suárez");
personas[2] = new Persona("95175364Y","Andrés","Rodríguez");
/* Creamos 3 objetos de tipo socio y los agregamos
* al array de tipo personas.
*
* AQUÍ VEREMOS EL POLIMORFISMO.*/
personas[3] =new Socio("85247196A","Sara","González",01);
personas[4] =new Socio("96547821H","Michelle","Vegas",02);
personas[5] =new Socio("75123481G","Ylenia","Fernández",03);
/* Imprimimos por pantalla los resultados*/
for(Persona p:personas) {
System.out.println("DNI: " + p.getDni()
+ " - Nombre: " + p.getNombre() +
" - Apellidos: " + p.getApellidos());
}
}
}
En este ejemplo se crean 3 objetos de cada clase, tanto de la clase persona como de la clase socio.
Por otro lado como vemos se crea un array de tipo personas.
- ¿Qué espera el array? Objetos de tipo persona, es decir, de la superclase o clase padre.
- ¿Socio es una subclase de la clase persona? Si, porque un socio es una persona y por tanto la clase socio hereda de la clase persona.
En este caso se dice que socio se está adaptando a la situación ya que los objetos de la clase socio (subclase), pueden guardarse dentro de un objeto de tipo Persona (superclase).
Esto es la propiedad de la programación orientada a objetos llamada polimorfismo en java.