Java Method Overriding

Q1. What is Method Overriding?

As stated earlier, overridden methods allow Java to support run-time polymorphism. Polymorphism is essential to object-oriented programming for one reason: it allows a general class to specify methods that will be common to all of its derivatives while allowing subclasses to define the specific implementation of some or all of those methods. Overridden methods are another way that Java implements the “one interface, multiple methods” aspect of polymorphism. Dynamic Method Dispatch is one of the most powerful mechanisms that object-oriented design brings to bear on code reuse and robustness. The ability to exist code libraries to call methods on instances of new classes without recompiling while maintaining a clean abstract interface is a profoundly powerful tool. Overridden methods allow us to call methods of any of the derived classes without even knowing the type of derived class object.  

Q2. When to apply Method Overriding? (with example)

Overriding and Inheritance: Part of the key to successfully applying polymorphism is understanding that the superclasses and subclasses form a hierarchy that moves from lesser to greater specialization. Used correctly, the superclass provides all elements that a subclass can use directly. It also defines those methods that the derived class must implement on its own. This allows the subclass the flexibility to define its methods, yet still enforces a consistent interface. Thus, by combining inheritance with overridden methods, a superclass can define the general form of the methods that will be used by all of its subclasses. Let’s look at a more practical example that uses method overriding. Consider an employee management software for an organization, let the code has a simple base class Employee, and the class has methods like raiseSalary(), transfer(), promote(), .. etc. Different types of employees like Manager, Engineer, ..etc may have their implementations of the methods present in base class Employee. In our complete software, we just need to pass a list of employees everywhere and call appropriate methods without even knowing the type of employee. For example, we can easily raise the salary of all employees by iterating through the list of employees. Every type of employee may have its logic in its class, we don’t need to worry because if raiseSalary() is present for a specific employee type, only that method would be called. 

 

 

Java

// Java program to demonstrate application // of overriding in Java   // Base Class class Employee {     public static int base = 10000;     int salary() { return base; } }   // Inherited class class Manager extends Employee {     // This method overrides salary() of Parent     int salary() { return base + 20000; } }   // Inherited class class Clerk extends Employee {     // This method overrides salary() of Parent     int salary() { return base + 10000; } }   // Driver class class Main {     // This method can be used to print the salary of     // any type of employee using base class reference     static void printSalary(Employee e)     {         System.out.println(e.salary());     }       public static void main(String[] args)     {         Employee obj1 = new Manager();           // We could also get type of employee using         // one more overridden method.loke getType()         System.out.print("Manager's salary : ");         printSalary(obj1);           Employee obj2 = new Clerk();         System.out.print("Clerk's salary : ");         printSalary(obj2);     } }

Output

Manager's salary : 30000
Clerk's salary : 20000

Related Article

• Dynamic Method Dispatch or Runtime Polymorphism in Java
• Overriding equals() method of Object class
• Overriding toString() method of Object class
• Overloading in java
• Output of Java program | Set 18 (Overriding)

In Java, Overriding is a feature that allows a subclass or child class to provide a specific implementation of a method that is already provided by one of its super-classes or parent classes. When a method in a subclass has the same name, the same parameters or signature, and the same return type(or sub-type) as a method in its super-class, then the method in the subclass is said to override the method in the super-class.

Method overriding is one of the ways by which Java achieves Run Time Polymorphism. The version of a method that is executed will be determined by the object that is used to invoke it. If an object of a parent class is used to invoke the method, then the version in the parent class will be executed, but if an object of the subclass is used to invoke the method, then the version in the child class will be executed. In other words, it is the type of the object being referred to (not the type of the reference variable) that determines which version of an overridden method will be executed.