Saltar al contenido principal

Redefinición y ocultación

Cuando una clase hereda una serie de atributos y métodos, en alguna ocasión puede ocurrir que interese modificar el tipo de algún atributo o redefinir un método. Este mecanismo se conoce como ocultación cuando es un atributo y redefinición para un método. Consiste en declarar un atributo o método con el mismo nombre que uno heredado, lo que hace que este sea ocultado y sustituido por el nuevo.

Redefinición de métodos

En Java, la redefinición de métodos (también llamada "sobrescritura" o overriding) permite que una subclase pueda modificar el comportamiento de un método heredado de su superclase. Esto es útil cuando quieres que una clase derivada tenga una funcionalidad particular que se diferencie de la de la clase padre.

Para redefinir un método en Java:

  • La subclase declara un método con el mismo nombre, tipo de retorno y parámetros que el método en la superclase.
  • El método redefinido en la subclase "sustituye" el comportamiento del método heredado.

Vamos a ver cómo redefinir un método. Partimos de la clase Persona y su subclase Empleado:

class Persona{
// Utiliza protected para que la clase hija pueda acceder a los atributos de la clase padre
// Aquí lo utilizo a modo de ejemplo, en un caso real deberían ser privados
protected String nombre;
protected byte edad;
protected double altura;

public void mostrarDatos() {
System.out.println(nombre);
System.out.println(edad);
System.out.println(altura);
}
}
class Empleado extends Persona {
private double salario; //Atributo propio

}

Tenemos que la clase Empleado dispone mediante herencia del método mostrarDatos(), pero este método no alcanza para mostrar la información de un empleado, ya que no muestra su salario.

Podemos redefinir este método en la clase Empleado. Aunque es opcional, los métodos sustituidos en las subclases se marcan con la notación @Override. Indica que el método es una sustitución de un método de la superclase. Veamos la redefinición en la clase Empleado:

class Empleado extends Persona {
private double salario; //Atributo propio

@Override // significa que sustituye a un método de la superclase
public void mostrarDatos() {
System.out.println(nombre);
System.out.println(edad);
System.out.println(altura);
System.out.println(salario);
}
}

Si ejecutamos el siguiente código, se ejecuta el método mostrarDatos() de la clase Empleado:

Empleado e = new Empleado();
e.mostrarDatos();

Ocultación de atributos

La ocultación de atributos (field hiding) ocurre cuando una subclase define un atributo con el mismo nombre que un atributo en su superclase. Esto no es lo mismo que la redefinición de métodos, ya que en Java los atributos no se pueden "redefinir" del mismo modo que los métodos. En cambio, cuando una subclase define un atributo con el mismo nombre que en la superclase, el atributo de la superclase queda oculto en el contexto de la subclase.

Si una subclase tiene un atributo con el mismo nombre que en la superclase, entonces:

  • La subclase "oculta" el atributo de la superclase cuando se accede a él desde la propia subclase.
  • Para acceder al atributo de la superclase, es necesario usar la palabra clave super.

Ahora veremos un ejemplo de ocultación de un atributo. La altura de un empleado (entendida como una longitud) no es un dato relevante para la empresa. Pero sí es interesante conocer la talla del uniforme y guardarla en el atributo altura. En este caso definimos alturacomo un string que contenga la talla del uniforme (S, M, L, XL, etc.).

Podríamos hacer esto por lo tanto:

class Empleado extends Persona {
private double salario; //Atributo propio
private String altura; //Atributo oculto

@Override // significa que sustituye a un método de la superclase
void mostrarDatos() {
// ...
}
}
Evitar ocultación de atributos

La ocultación de atributos puede llevar a confusiones y errores de código, por lo que generalmente es una buena práctica evitar definir atributos con el mismo nombre en superclases y subclases.