Sobreescritura
!Bienvenidos a la Wiki del Proyect "Sobreescritura"
El proyecto "Sobreescritura" es un proyecto desarrollado en el lenguaje Java que describe y ejemplifica el uso de la "sobreescritura de métodos"(overriding), el uso del "polimorfismo" y del operador "instanceof".
La sobreescritura de métodos (overriding) es un concepto fundamental en la programación orientada a objetos (POO) y permite a una clase derivada proporcionar su propia implementación de un método heredado de una clase base. En Java, se utiliza la anotación @Override para indicar que un método está siendo sobreescrito.
Cuando una clase deriva de otra clase y declara un método con la misma firma (nombre, parámetros y tipo de retorno) que un método en la clase padre, se produce la sobreescritura de método. Esto permite modificar el comportamiento del método en la clase hija sin alterar la implementación original en la clase base.
La sobreescritura de métodos se basa en el principio del polimorfismo, lo que significa que un objeto de la clase hija puede ser tratado como un objeto de la clase padre. Cuando se invoca el método sobreescrito en un objeto de la clase hija, la implementación del método en la clase hija se ejecuta en lugar de la implementación en la clase padre.
package domain;
public class Empleado {
protected String nombre;
protected double sueldo;
-
Se crea un Constructor para la clase padre:
public Empleado(String nombre, double sueldo){ this.nombre = nombre; this.sueldo = sueldo; } -
Se construye el Método que se va a sobreescribir en la clase hija:
public String obtenerDetalles(){ return "Nombre: "+this.nombre+", Sueldo: "+this.sueldo; } -
Se agregan los métodos getters y setters para los atributos de nombre y sueldo:
public String getNombre() { return nombre; } public void setNombre(String nombre) { this.nombre = nombre; } public double getSueldo() { return sueldo; } public void setSueldo(double sueldo) { this.sueldo = sueldo; }
-
Se colocan los atributos:
package domain; public class Gerente extends Empleado { private String departamento; -
Utilizamos el constructor, llamamos al constructor de la clase padre para acceder a sus atributos
-
Inicializamos el atributo de la clase hija:
public Gerente(String nombre, double sueldo, String departamento){ super(nombre, sueldo); this.departamento = departamento; } -
Se utiliza la anotación @Override para indicar que el método de la clase padre está siendo sobreescrito:
@Override public String obtenerDetalles(){ return super.obtenerDetalles()+", Departamento: "+this.departamento } }
-
Trabajamos con un objeto de la clase hija (Gerente) utilizando el método obtenerDetalles (método para la sobreescrituración) de la clase padre (Empleado):
-
Se crea el método main
-
Se crea un objeto de tipo Gerente
import domain.Gerente; public class TestSobreescritura { public static void main(String[] args) { Gerente gerente1 = new Gerente("José", 5000, "Sistemas"); System.out.println("gerente1 = " + gerente1.obtenerDetalles()); } }
Obteniendo como salida: gerente1 = Nombre: José, Sueldo: 5000.0, Departamento: Sistemas
El polimorfismo permite tratar objetos de diferentes clases de manera uniforme. En Java, el polimorfismo se logra a través de la herencia y la sobreescritura de métodos. La herencia permite que una clase derive de otra clase, heredando sus métodos y propiedades. La sobreescritura de métodos, por otro lado, permite que una clase hija proporcione su propia implementación de un método heredado de la clase padre.
El polimorfismo se basa en la idea de que un objeto de una clase hija puede ser tratado como un objeto de la clase padre. Esto significa que se puede tener una referencia de la clase padre que apunta a un objeto de la clase hija y llamar a los métodos de la clase hija a través de esa referencia. Se llamará a ese método a través de una referencia de la clase padre y la implementación del método en la clase hija se ejecutará en lugar de la implementación original en la clase padre.
-
Se importan todas las clases que están dentro del paquete domain:
import domain.*; -
Dentro del metodo main:
-
Se definen variables de la clase padre
-
Se define una variable de la clase hija
public class TestSobreescritura { public static void main(String[] args) { Empleado empleado1 = new Empleado ("Juan", 10000); imprimir(empleado1); empleado1 = new Gerente ("José", 5000, "Sistemas"); imprimir(empleado1); } -
Se crea el método imprimir para llamar al método obtenerDetalles:
Dependiendo de la referencia del objeto se va a ejecutar de la clase padre o de la clase hija
public static void imprimir(Empleado empleado){
String detalles = empleado.obtenerDetalles();
System.out.println("detalles = " + detalles);
}
}
Obteniendo como salida para la clase padre: detalles = Nombre: Juan, Sueldo: 10000.0
Obteniendo como salida para la clase hija: empleado = Nombre: José, Sueldo: 5000.0, Departamento: Sistemas
El operador instanceof en Java es un operador que se utiliza para comprobar si un objeto es una instancia de una clase específica o una subclase de esa clase. Proporciona una forma de verificar la relación de herencia entre un objeto y una clase o interfaz en tiempo de ejecución.
La sintaxis del operador instanceof es la siguiente: objeto instanceof Clase
Donde objeto es el objeto que deseas comprobar y Clase es la clase (o interfaz) que deseas verificar.
El operador instanceof devuelve un valor booleano: true si el objeto es una instancia de la clase o subclase especificada, y false en caso contrario.
Es importante tener en cuenta que el operador instanceof solo verifica la relación de herencia en tiempo de ejecución y no en tiempo de compilación. Además, si un objeto es nulo (null), el operador instanceof siempre devuelve false.
public class TestInstanceOf {
public static void main(String[] args) {
Empleado empleado1 = new Empleado("Juan", 10000);
//determinarTipo(empleado1);
empleado1 = new Gerente ("José", 5000, "Sistemas");
determinarTipo(empleado1);
}
-
Método para determinar el tipo en tiempo de ejecución, empleando el operador instanceof (permite preguntar de que tipo es la referencia a la cual apunta cierta variable)
Se empieza preguntando por las clases más específicas, las clases hijas (Gerente), luego por las más genéricas (Empleado, Object)
public static void determinarTipo(Empleado empleado){ if(empleado instanceof Gerente){ System.out.println("Es de tipo Gerente"); } else if(empleado instanceof Empleado){ System.out.println("Es de tipo Empleado"); } else if(empleado instanceof Object){ System.out.println("Es de tipo Object"); } } }
Obteniendo como salida: "Es de tipo Gerente"
Si estas interesado en ampliar tus conocimientos sobre sobreescritura de métodos, polimorfismo e instanceof a contuniación encontraras los enlaces a la documentación oficial de Oracle-Java:
