Diferentes formas de evitar la anulación de métodos en Java

La herencia es una regla sustancial de cualquier lenguaje de programación orientada a objetos (OOP), pero aún así, hay formas de evitar la anulación de métodos en clases secundarias que son las siguientes:

Métodos:

1. Usando un método estático
2. Usando el modificador de acceso privado
3. Uso del modificador de acceso predeterminado
4. Usando el método de palabra clave final

Método 1: Usar un método estático

Esta es la primera forma de evitar la anulación de métodos en la clase secundaria. Si hace que un método sea estático, se convierte en un método de clase y no en un método de objeto y, por lo tanto, no se permite anularlo, ya que se resuelven en el momento de la compilación y los métodos anulados se resuelven en el tiempo de ejecución.

// Java Program to Prevent Method Overriding
// using a static method
 
// Importing java input output classes
import java.io.*;
 
// Class 1
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating an object og Base class
        Base base = new Child();
 
        // Printing message from base class as
        // its static methods have static binding
 
        // Hence even if the object is of Child class
        //  message printed is from base class
        base.hello();
    }
}
 
// Class 2
// Parent class
class Base {
 
    // hello() method of parent class
    public static void hello()
    {
 
        // Print and display the message if
        // hello() method of parent class is called
        System.out.println("Hello from base class");
    }
}
 
// Class 3
// Child class
class Child extends Base {
 
    // Overriding the existing method - hello()
    // @Override
    // hello() method of child class
    public static void hello()
    {
        // Print and display the message if
        // hello() method of child class is called
        System.out.println("Hello from child class");
    }
}

Hello from base class

Método 2 Uso del modificador de acceso privado
 
Hacer que cualquier método sea privado reduce el alcance de ese método a la clase solamente, lo que significa que absolutamente nadie fuera de la clase puede hacer referencia a ese método.

Ejemplo

// Java Program to Prevent Method Overriding
// using a private method specifier
 
// Importing input output classes
import java.io.*;
 
// Class 1
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating an object of Child class
        Child child = new Child();
 
        // Calling hello() method in main()
        child.hello();
    }
}
 
// Class 2
// Helper class 1
// Child Class
class Child extends Base {
 
    //@Override
    // hello() method of child class
    public void hello()
    {
 
        // Print statement when hello() method of
        // child class is called
        System.out.println("Hello from child class");
    }
}
 
// Class 3
// Helper class 2
// Parent Class
class Base {
 
    // hello() method of parent class
    private void hello()
    {
 
        // Print statement when hello() method of
        // child class is called
        System.out.println("Hello from base class");
    }
}

Hello from child class

Método 3 Usando el modificador de acceso predeterminado

Esto solo se puede usar cuando la anulación del método está permitida dentro del mismo paquete pero no fuera del paquete. El modificador predeterminado permite que el método sea visible solo dentro del paquete, por lo que cualquier clase secundaria fuera del mismo paquete nunca puede anularlo.
 

Ejemplo 

// Java Program to Prevent Method Overriding
// using a private method specifier
 
// Importing input output classes
import java.io.*;
 
// Class 1
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an object of base class
        Base base = new Child();
 
        // Calling hello() method using Base class object
        base.hello();
    }
}
 
// Class 2
// Parent class
class Base {
 
    // hello() method of parent class
    private void hello()
    {
 
        // Print statement when hello() method of
        // child class is called
        System.out.println("Hello from base class");
    }
}
 
// Class 3
// Child class
class Child extends Base {
 
    // Overriding existing method
    // @Override
 
    // Hello method of child class
    void hello()
    {
 
        // Print statement when hello() method
        // of child class is called
        System.out.println("Hello from child class");
    }
}

Producción:

 
Método 4: Usar el método de palabra clave final

La forma final de evitar la anulación es utilizando la palabra clave final en su método. La palabra clave final pone fin a ser una herencia. Por lo tanto, si un método se convierte en final, se considerará la implementación final y ninguna otra clase puede anular el comportamiento.

// Java Program to Prevent Method Overriding
// using a final keyword method
 
// Importing input output classes
import java.io.*;
 
// Class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating object of Child class
        Child child = new Child();
 
        // Calling hello() method using Child class object
        child.hello();
    }
}
 
// Class 2
// Child class
class Child extends Base {
 
    // Overriding
    // @Override
 
    // Method of child class
    public void hello()
    {
        // Print statement for Child class
        System.out.println("Hello from child class");
    }
}
 
// Class 3
// Base class
class Base {
 
    // Method of parent class
    public final void hello()
    {
        // Print statement for Base(parent) class
        System.out.println("Hello from base class");
    }
}

Producción: