Java Sobrescritura (Override) y Sobrecarga (Overload)

Sobrescritura (Override)

La sobrescritura (Override) se refiere a que una subclase define un método que tiene el mismo nombre, lista de parámetros y tipo de retorno que uno de su clase padre, y la implementación del método de la subclase reemplaza la implementación del método de la clase padre.Es decir, la apariencia no cambia, ¡el núcleo se sobrescribe!

La ventaja de la sobrescritura es que la subclase puede definir comportamientos específicos para sí misma según sea necesario. Es decir, la subclase puede implementar el método de la clase padre según sus necesidades. Así, al usar un objeto de la subclase para llamar a este método, se ejecutará el método de la subclase en lugar del de la clase padre.

Un método sobrescrito no puede lanzar nuevas excepciones verificadas o excepciones más amplias que las declaradas por el método sobrescrito. Por ejemplo: un método de la clase padre declara una excepción verificada IOException, pero al sobrescribir este método no se puede lanzar una excepción Exception, porque Exception es la clase padre de IOException; se puede lanzar IOException o excepciones subclase de IOException.

En los principios de la programación orientada a objetos, sobrescribir significa que se puede sobrescribir cualquier método existente. Ejemplo:

Código del archivo TestDog.java:

class Animal{ public void move(){ System.out.println("El animal puede moverse"); } } class Dog extends Animal{ public void move(){ System.out.println("El perro puede correr y caminar"); } } public class TestDog{ public static void main(String args[]){ Animal a = new Animal(); //Objeto Animal Animal b = new Dog(); //Objeto Dog a.move();//Ejecutar el método de la clase Animal b.move();//Ejecutar el método de la clase Dog } }

El resultado de compilar y ejecutar el ejemplo anterior es el siguiente:

Los animales pueden moverse
Los perros pueden correr y caminar

En el ejemplo anterior se puede ver que, aunque b es de tipo Animal, ejecuta el método move de la clase Dog.

Esto se debe a que en la fase de compilación solo se verifica el tipo de referencia del parámetro.

Sin embargo, en tiempo de ejecución, la máquina virtual de Java (JVM) determina el tipo del objeto y ejecuta el método de ese objeto.

Por lo tanto, en el ejemplo anterior, la compilación tiene éxito porque el método move existe en la clase Animal, pero en tiempo de ejecución se ejecuta el método del objeto específico.

Considera el siguiente ejemplo:

Código del archivo TestDog.java:

class Animal{ public void move(){ System.out.println("El animal puede moverse"); } } class Dog extends Animal{ public void move(){ System.out.println("El perro puede correr y caminar"); } public void bark(){ System.out.println("El perro puede ladrar"); } } public class TestDog{ public static void main(String args[]){ Animal a = new Animal(); //Objeto Animal Animal b = new Dog(); //Objeto Dog a.move();//Ejecutar el método de la clase Animal b.move();//Ejecutar el método de la clase Dog b.bark(); } }

El resultado de compilar y ejecutar el ejemplo anterior es el siguiente:

TestDog.java:30: cannot find symbol
symbol  : method bark()
location: class Animal
                b.bark();
                 ^

Este programa lanzará un error de compilación porque el tipo de referencia Animal de b no tiene el método bark.

Reglas de sobrescritura de métodos

  • La lista de parámetros debe ser exactamente igual a la lista de parámetros del método sobrescrito.

  • El tipo de retorno puede ser diferente al del método sobrescrito, pero debe ser una clase derivada del valor de retorno de la clase padre (en Java 5 y versiones anteriores el tipo de retorno debe ser el mismo; en Java 7 y versiones posteriores puede ser diferente).

  • El modificador de acceso no puede ser más restrictivo que el del método sobrescrito en la clase padre. Por ejemplo: si un método de la clase padre se declara como public, al sobrescribirlo en la subclase no se puede declarar como protected.

  • Los métodos miembro de la clase padre solo pueden ser sobrescritos por sus subclases.

  • Los métodos declarados como final no pueden sobrescribirse.

  • Los métodos declarados como static no pueden sobrescribirse, pero pueden volver a declararse.

  • Si la subclase y la clase padre están en el mismo paquete, la subclase puede sobrescribir todos los métodos de la clase padre, excepto los declarados como private y final.

  • Si la subclase y la clase padre no están en el mismo paquete, la subclase solo puede sobrescribir los métodos no final declarados como public y protected de la clase padre.

  • Un método sobrescrito puede lanzar cualquier excepción no verificada, independientemente de si el método sobrescrito lanza excepciones. Sin embargo, el método sobrescrito no puede lanzar nuevas excepciones verificadas, ni excepciones verificadas más amplias que las declaradas por el método sobrescrito; en cambio, lo contrario sí está permitido.

  • Los métodos constructores no pueden sobrescribirse.

  • Si no se puede heredar una clase, no se pueden sobrescribir sus métodos.

Uso de la palabra clave Super

Cuando se necesita llamar al método sobrescrito de la clase padre dentro de la subclase, se debe usar la palabra clave super.

Código del archivo TestDog.java:

class Animal{ public void move(){ System.out.println("El animal puede moverse"); } } class Dog extends Animal{ public void move(){ super.move(); //Aplicar el método de la superclase con super System.out.println("El perro puede correr y caminar"); } } public class TestDog{ public static void main(String args[]){ Animal b = new Dog(); //Objeto Dog b.move(); //Ejecutar el método de la clase Dog } }

El resultado de compilar y ejecutar el ejemplo anterior es el siguiente:

Los animales pueden moverse
Los perros pueden correr y caminar

Sobrecarga (Overload)

La sobrecarga (overloading) consiste en que, dentro de una clase, los métodos tienen el mismo nombre pero diferentes parámetros. El tipo de retorno puede ser igual o diferente.

Cada método sobrecargado (o constructor) debe tener una lista de tipos de parámetros única.

El uso más común es la sobrecarga de constructores.

Reglas de sobrecarga:

  • El método sobrecargado debe cambiar la lista de parámetros (diferente número o tipo de parámetros);
  • El método sobrecargado puede cambiar el tipo de retorno;
  • El método sobrecargado puede cambiar el modificador de acceso;
  • El método sobrecargado puede declarar excepciones verificadas nuevas o más amplias;
  • Los métodos pueden sobrecargarse en la misma clase o en una subclase.
  • No se puede utilizar el tipo de retorno como criterio para distinguir funciones sobrecargadas.

Ejemplo

Código del archivo Overloading.java:

public class Overloading { public int test(){ System.out.println("test1"); return 1; } public void test(int a){ System.out.println("test2"); } //Los siguientes dos métodos tienen el orden de los tipos de parámetros diferente. public String test(int a,String s){ System.out.println("test3"); return "returntest3"; } public String test(String s,int a){ System.out.println("test4"); return "returntest4"; } public static void main(String[] args){ Overloading o = new Overloading(); System.out.println(o.test()); o.test(1); System.out.println(o.test(1,"test3")); System.out.println(o.test("test4",1)); } }

Diferencias entre sobrescritura y sobrecarga

Punto de diferencia Método sobrecargado Método sobrescrito
Lista de parámetros Debe modificarse No debe modificarse
Tipo de retorno Puede modificarse No debe modificarse
Excepciones Pueden modificarse Pueden reducirse o eliminarse, no deben lanzarse excepciones nuevas o más amplias
Acceso Puede modificarse No debe hacerse más restrictivo (puede reducirse la restricción)

Resumen

La sobrescritura (Overriding) y la sobrecarga (Overloading) de métodos son diferentes manifestaciones del polimorfismo en Java. La sobrescritura es una manifestación del polimorfismo entre una clase padre y una subclase; la sobrecarga puede entenderse como una forma concreta de manifestación del polimorfismo.

  • (1) La sobrecarga de métodos se refiere a que en una clase se definen varios métodos con el mismo nombre, pero con diferente número de parámetros, o con el mismo número pero diferente tipo y orden; esto se denomina sobrecarga de métodos (Overloading).
  • (2) La sobrescritura de métodos se refiere a que en una subclase existe un método con el mismo nombre que el método de la clase padre, y con el mismo número y tipo de parámetros, y también el mismo valor de retorno; esto se denomina sobrescritura (Overriding).
  • (3) La sobrecarga de métodos es una manifestación del polimorfismo de una clase, mientras que la sobrescritura de métodos es una manifestación del polimorfismo entre una subclase y una clase padre.

Otras extensiones