Java / Override

Bienvenidos sean a este post, hoy hablaremos sobre anulacion (override) el cual es un procedimiendo concedido a una sub clase para poder anular uno o varios metodos de la super clase.

El beneficio de trabajar de esta forma es permitirnos redefinir de forma mas especifica un metodo de nuestra super clase para nuestra sub clase, resumiendo esto significa que anular es redefinir la funcionalidad de un metodo.

Nota: recuerden que el metodo debe existir en la clase super y en la clase sub pero lo unico que cambiara son las instrucciones en ambos.

Para entender esto veamos el siguiente ejemplo:

PruebaPerro.java

class Animal
{
        public void mover()
        {
                System.out.println("Los animales se mueven");
        }
}

class Perro extends Animal
{
        public void mover()
        {
                System.out.println("Los perros se mueven tambien");
        }
}

public class PruebaPerro
{
        public static void main(String[] args)
        {
                Animal a = new Animal();
                Animal b = new Perro();

                a.mover();
                b.mover();
        }
}

En este ejemplo tendremos una super clase llamada Animal la cual tendra un metodo llamado mover() con un mensaje relacionado a la clase, luego crearemos la clase heredera de la anterior llamada Perro, y en esta tambien tendremos un metodo llamado mover() con otro mensaje para diferenciar las funciones, luego crearemos la clase principal con el metodo main(), en ella crearemos un objeto de la clase Animal llamado a, despues crearemos un objeto referenciado a la clase Animal llamado b pero el objeto sera de tipo Perro por el metodo new y el constructor de la clase Perro. Despues llamaremos al metodo mover() de cada clase, si lo compilamos y lo ejecutamos veremos esta salida:

tinchicus@dbn001vrt:~/programacion/java/program$ java PruebaPerro
Los animales se mueven
Los perros se mueven tambien
tinchicus@dbn001vrt:~/programacion/java/program$

Como pueden ver se llamaron a los dos metodos correctamente, a pesar de estar referenciados a la clase Animal pero los metodos se diferenciaron correctamente a pesar de tener las mismas caracteristicas, a diferencia de la sobrecarga, pero distintas instrucciones en las mismas, tomemos el ejemplo anterior pero ahora modifiquemos la clase Perro de la siguiente forma:

class Perro extends Animal
{
        public void mover()
        {
                System.out.println("Los perros se mueven tambien");
        }

        public void ladrar();
        {
                System.out.println("Guauuuu");
        }
}

Y agreguen la siguiente linea dentro del cuerpo de main() despues de b.mover():

b.ladrar();

Ahora si compilamos nuestro nuevo programa nos sucedera lo siguiente:

tinchicus@dbn001vrt:~/programacion/java/program$ javac PruebaPerro.java
 PruebaPerro.java:31: error: cannot find symbol
                 b.ladrar();
                  ^
   symbol:   method ladrar()
   location: variable b of type Animal
 1 error
 tinchicus@dbn001vrt:~/programacion/java/program$

Esto es debido a que no definimos un metodo llamado ladrar en Animal, aunque sea vacio, y como dijimos al principio para una anulacion (override) se debe tener el metodo con el mismo nombre en ambas clases, una solucion podria ser agregar dentro de la clase Animal el siguiente metodo:

public void ladrar() {}

Si lo volvemos a compilar y lo ejecutamos obtendremos las siguiente salida:

tinchicus@dbn001vrt:~/programacion/java/program$ java PruebaPerro
Los animales se mueven
Los perros se mueven tambien
Guauuuu
tinchicus@dbn001vrt:~/programacion/java/program$

Nuestro codigo final quedo de la siguiente forma:

class Animal
{
        public void mover()
        {
                System.out.println("Los animales se mueven");
        }
        public void ladrar() {}
}

class Perro extends Animal
{
        public void mover()
        {
                System.out.println("Los perros se mueven tambien");
        }

        public void ladrar()
        {
                System.out.println("Guauuuu");
        }
}

public class PruebaPerro
{
        public static void main(String[] args)
        {
                Animal a = new Animal();
                Animal b = new Perro();

                a.mover();
                b.mover();
                b.ladrar();
        }
}

Pasemos a hablar sobre algunas reglas que se deben respetar para efectuar correctamente una anulacion (overriding):

• La lista de argumentos debe ser exactamente la misma en ambos metodos
• El tipo de retorno debe ser el mismo
• Tambien puede ser un subtipo del tipo de retorno declarado en el metodo de la super clase
• El nivel de acceso de la subclase no puede ser mas restrictivo que el metodo de la superclase, p.e. el metodo original es public el metodo de la subclase no puede ser private o protected
• Los metodos pueden ser anulados solo si son herederos por la subclase
• Un metodo declarado como final no puede ser anulado
• Un metodo declarado como static no puede ser anulado pero puede ser re-declarado
• Si un metodo no puede ser heredado no puede ser anulado
• Una subclase dentro del mismo paquete que la super clase instanciadora puede anular cualquier super clase que no sea declarada como private o final
• Una subclase en otro paquete solo puede anular metodos no final declarados como public o private
• Cualquier anulacion de metodo puede enviar cualquier excepcion sin chequear, este puede enviar cercanas o pocas excepciones a los metodos anulados
• Los constructores no pueden ser anulados

Por ultimo nosotros podemos invocar en un metodo anulado al metodo de la super clase, para ello utilizaremos la palabra super y lo veremos en el siguiente ejemplo:

Prueba_Perro.java

class Animal
{
        public void mover()
        {
                System.out.println("Los animales se mueven");
        }
}

class Perro extends Animal
{
        public void mover()
        {
                super.mover();
                System.out.println("Los perros se mueven tambien");
        }
}

public class Prueba_Perro
{
        public static void main(String[] args)
        {
                Animal p = new Perro();
                p.mover();
        }
}

Este ejemplo es muy similar al anterior pero nuestra diferencia esta en el metodo mover() de nuestra clase Perro, donde por medio de la siguiente linea:

super.mover();

Llamaremos al metodo mover de la super clase y luego mostrara el nuevo mensaje, en main() volvemos a crear un objeto de tipo Perro llamado p pero esta referenciado a la clase Animal, para luego llamar al metodo mover() de la clase Perro, si lo compilamos y ejecutamos podremos ver la siguiente salida:

tinchicus@dbn001vrt:~/programacion/java/program$ java Prueba_Perro
Los animales se mueven
Los perros se mueven tambien
tinchicus@dbn001vrt:~/programacion/java/program$

Podemos ver como se ejecuta el metodo mover() de la super clase y luego el mensaje de nuestro metodo de la sub clase.

Nota: Como anulacion o anular no suena tan armonioso es posible que escuchen o vean este tema como sobreescribir, redefinir o reescribir pero esto corresponde a override, en los proximos posts me inclinare mas a redefinir o sobreescribir.

En resumen, hoy hemos visto que es la anulacion (overriding), como se utiliza, para que se utiliza, de que forma se debe utilizar correctamente, unas reglas simples para implementarlas, la diferencia con la sobrecarga, y el uso de la palabra super para nuestros metodos anuladores, espero les haya sido util sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.

Tengo un Patreon donde podes acceder de manera exclusiva a material para este blog antes de ser publicado, sigue los pasos del link para saber como.