Here we will be discussing why should we prevent method overriding in java. So, before going into the topic, let’s give a look at the below important concept then we will move to the actual topic. As we know Object Oriented Programming (OOPs) concept consists of 4 important concepts that are as follows:
Polymorphism is one of the important pillars among the 4 pillars of Oops which refers to performing a single action in different ways. This means the object behaves differently under different conditions. It is divided into 2 major types i.e.
- Compile-time polymorphism OR Static polymorphism OR Early binding.
- Example: Method Overloading
- Run time polymorphism OR Dynamic polymorphism OR Late binding.
- Example: Method Overriding
Both Method overloading and Method Overriding have some differences between them as well. While working practically on a project there arises some situations when we need to implement overloading or overriding as well at some scenarios we need to prevent overloading and overriding. As our topic aims to focus on ‘Why should we prevent method overriding ?’ let’s move to that part. While working on any project we avoid method overriding in different ways mostly for two reasons listed and further discussed below:
- Performance parameter
- Design decision
Let us discuss and implement them by going through them to a certain depth.
Reason 1: Performance Parameter
In overriding JVM performs extra stuff at run time which affects performance. Yes, it’s method binding which means that method will be called is decided at run time based on the actual object pointed by reference, so it takes extra time whereas in static binding during compile time which method will be called is decided(function call binds with the appropriate method). So, it’s clear we are preventing overriding means we are preventing run-time binding and we are preventing run-time binding means we are saving time and increasing performance. So, sometimes we prevent overriding to improve the performance of software applications.
Reason 2: Design Decision
In many scenarios/situations, we do not want to change the behavior of particular base class methods by their derived classes. This means we want to keep the parent class method as it is and not be changed by its child class.
Implementation:
We have a Base class Car and a derived class Skoda Car where the Base class has 3 methods as listed below:
- speed()
- condition()
- maintenance()
Here we want the speed() method to remain the same as it is and the other two methods condition() method and maintenance() method to be changed(means body provided in derived class). it is as discussed in the below example.
Example
Java
// Java Program to illustrate Prevention method overriding// Importing input output classesimport java.io.*;// Class 1// Base classclass 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 classclass 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 classclass 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
