Mosos del sistema operativo

sobreescritura de metodos en java

Cada vez que se tiene una clase que hereda un método de una superclase, se tiene la oportunidad de sobreescribir el método (a menos que dicho método esté marcado como final). El beneficio clave al sobreescribir un método heredado es la habilidad de definir un comportamiento específico para los objetos de la subclase.Veamos un ejemplo de la sobreescritura deun método heredado:

public class Animal {

public void comer(){
System.out.println("Animal comiendo...");
}
}

class Caballo extends Animal{
public void comer(){
System.out.println("Caballo comiendo...");
}
}

Al momento de que Caballo hereda de la clase Animal obtiene el método comer() definido en Animal, sin embargo, se desea especificar un poco más el comportamiento de Caballoal momento de llamar a comer(), por lo tanto se define un método con el mismo nombre dentro de la clase Caballo. Debido a que ambos métodos tienen el mismo nombre, para saber qué método se invocará en tiempo de ejecución es necesario saber a qué objeto se está refiriendo. P. ej.:

public static void main(String... args){
Animal a = new Animal();
Caballo c = new Caballo();
a.comer();c.comer();
}

Al ejecutar el código anterior obtenemos lo siguiente:

Animal comiendo...
Caballo comiendo...

Ahora en su versión polimórfica:

public static void main(String... args){
Animal a = new Caballo();
Caballo c = new Caballo();
a.comer();
c.comer();
}

Obtenemos lo siguiente:

Caballo comiendo...
Caballo comiendo...

En la primera ejecución del método tenemos unareferencia a un Animal pero el objeto es un Caballo, por lo tanto, el método invocado es la versión definida en la clase Caballo. Es importante mencionar que al momento de invocar un método sobre una referencia Animal en un objeto Caballo solamente se podrá ejecutar el métodos si la clase Animal lo define, p. ej.:

class Animal {

public void comer(){
System.out.println("Animal comiendo...");
}
}class Caballo extends Animal{
public void comer(){
System.out.println("Caballo comiendo...");
}
public void relinchar(){
System.out.println("Caballo relinchando...");
}
}

class ProbarMetodos{

public static void main(String... args){
Animal a = new Caballo();
Caballo c = new Caballo();
a.comer();
c.comer();
a.relinchar(); //error!
}
}

Aún cuando la clase Caballo define unmétodo llamado relinchar(), la clase Animal no sabe que dicho método existe, por lo tanto, el compilador arrojará un error cuando se intente invocar al método relinchar() desde una referencia Animal, no importa que el objeto Caballo sí lo tenga.

Reglas para sobreescribir un método::

Las reglas básicas para la sobreescritura de métodos son las siguientes:

+ La lista de argumentos delmétodo debe ser exactamente la misma.
+ El tipo de retorno debe de ser el mismo o un subtipo del tipo de retorno declarado originalmente.
+ El nivel de acceso no debe de ser más restrictivo.
+ El nivel de acceso puede ser menos restrictivo.
+ Los métodos de instancia pueden ser sobreescritos solamente si han sido heredados por la subclase.
+ Los métodos sobreescritos pueden arrojar cualquierexcepción no verificada(de tiempo de ejecución) por el compilador.
+ Los métodos sobreescritos NO pueden arrojar excepciones verificadas por el compilador.
+ No se puede sobreescibir un método marcado como final.
+ No se puede sobreescibir un método marcado como estático (static).
+ Si un método no puede ser heredado, no puede ser sobreescrito.

Invocar la versión de la superclase de un métodosobreescrito::

En algunas ocasiones necesitamos invocar al método escrito en la superclase en lugar de la versión que hemos sobreescrito, para ello se utiliza la palabra super seguida de un punto(.) y posteriormente el nombre del método a invocar, p. ej.:

class Caballo extends Animal{
public void comer(){
super.comer();
}
}

Sobrecarga de métodos en Java(Overloading)

Un método...