¿Cuándo necesitamos evitar la anulación de métodos en Java?

Aquí discutiremos por qué debemos evitar la anulación de métodos en java. Entonces, antes de entrar en el tema, echemos un vistazo al concepto importante a continuación y luego pasaremos al tema real. Como sabemos, el concepto de Programación Orientada a Objetos (POO) consta de 4 conceptos importantes que son los siguientes:

1. Encapsulación
2. Herencia
3. Polimorfismo
4. Abstracción

El polimorfismo es uno de los pilares importantes entre los 4 pilares de Oops, que se refiere a realizar una sola acción de diferentes maneras. Esto significa que el objeto se comporta de manera diferente bajo diferentes condiciones. Se divide en 2 tipos principales, es decir

1. Polimorfismo en tiempo de compilación O Polimorfismo estático O Enlace anticipado.
   • Ejemplo: sobrecarga de métodos
2. Polimorfismo de tiempo de ejecución O Polimorfismo dinámico O Enlace tardío.
   • Ejemplo: anulación de métodos

Tanto la sobrecarga de métodos como la anulación de métodos también tienen algunas diferencias entre ellos. Mientras trabajamos prácticamente en un proyecto, surgen algunas situaciones en las que necesitamos implementar la sobrecarga o la anulación, así como en algunos escenarios que necesitamos para evitar la sobrecarga y la anulación. Como nuestro tema tiene como objetivo centrarse en ‘¿Por qué debemos evitar la anulación de métodos?’ vamos a pasar a esa parte. Mientras trabajamos en cualquier proyecto, evitamos la anulación de métodos de diferentes maneras, principalmente por dos razones enumeradas y discutidas a continuación:

1. Parámetro de rendimiento
2. Decisión de diseño

Discutámoslos e implementémoslos repasándolos hasta cierto punto.

Razón 1: Parámetro de rendimiento

Al anular, JVM realiza cosas adicionales en tiempo de ejecución que afectan el rendimiento. Sí, es el enlace del método, lo que significa que el método que se llamará se decide en tiempo de ejecución en función del objeto real señalado por referencia, por lo que lleva más tiempo, mientras que en el enlace estático durante el tiempo de compilación se decide qué método se llamará (la llamada a la función se une con el método apropiado). Entonces, está claro que estamos evitando la anulación significa que estamos evitando el enlace en tiempo de ejecución y estamos evitando el enlace en tiempo de ejecución significa que estamos ahorrando tiempo y aumentando el rendimiento. Por lo tanto, a veces evitamos la anulación para mejorar el rendimiento de las aplicaciones de software.

Razón 2: decisión de diseño

En muchos escenarios/situaciones, no queremos cambiar el comportamiento de métodos particulares de clase base por sus clases derivadas. Esto significa que queremos mantener el método de la clase principal tal como está y que su clase secundaria no lo cambie.

Implementación:

Tenemos un automóvil de clase base y un automóvil Skoda de clase derivada donde la clase base tiene 3 métodos, como se indica a continuación:

• velocidad()
• condición()
• mantenimiento()

Aquí queremos que el método speed() siga siendo el mismo y que se cambien los otros dos métodos, el método condition() y el método maintenance() (significa el cuerpo proporcionado en la clase derivada). es como se explica en el siguiente ejemplo.

Ejemplo

// Java Program to illustrate Prevention method overriding
 
// Importing input output classes
import java.io.*;
 
// Class 1
// Base class
class Car {
 
    // We do not want speed to be changed change in base
    // class, so we will not provide any body to speed()
    // method in derived class So we will provide new body
    // to condition() method and maintenance() method in
    // derived class
 
    // Methods of this class
    public final void speed()
    {
 
        // Print statement
        System.out.println("Maximum speed allowed");
    }
    public void condition()
    {
        // Print statement
        System.out.println("good");
    }
    public void maintenance()
    {
        // Print statement
        System.out.println("required");
    }
}
 
// Class 2
// Derived class
class Skoda_Car extends Car {
    public void condition()
    {
 
        // Print statement
        System.out.println("Car condition good");
    }
 
    public void maintenance()
    {
 
        // Print statement
        System.out.println("Maintenance not required");
    }
}
 
// Class 3
// Main class
class Main {
 
    // Main drive method
    public static void main(String[] args)
    {
 
        // Here Parent class reference refers to
        // a Child object so child class methods will be
        // called This is known as run -time polymorphism
 
        // Creating an object of child class in Main class
        Skoda_Car c = new Skoda_Car();
 
        // Calling methods in Base class over object created
        // above
        c.speed();
        c.condition();
        c.maintenance();
    }
}

Maximum speed allowed
Car condition good
Maintenance not required