Overriding in Java – Flickroom

In any object-oriented program language, Overriding is a feature that allows a subclass or child class to provide a particular implementation of a method acting that is already provided by one of its super-classes or parent classes. When a method acting in a subclass has the lapp name, like parameters or signature, and same return type ( or sub-type ) as a method in its super-class, then the method acting in the subclass is said to override the method in the super-class. Method override is one of the way by which java achieve Run Time Polymorphism .The interpretation of a method acting that is executed will be determined by the object that is used to invoke it. If an object of a rear class is used to invoke the method, then the version in the parent course will be executed, but if an object of the subclass is used to invoke the method, then the interpretation in the child class will be executed. In other words, it is the type of the aim being referred to ( not the type of the character variable ) that determines which version of an override method will be executed.

class Parent {      void show()      {          System.out.println( "Parent's show()" );      } }   class Child extends Parent {           @Override      void show()      {          System.out.println( "Child's show()" );      } }   class Main {      public static void main(String[] args)      {                                     Parent obj1 = new Parent();          obj1.show();                                                Parent obj2 = new Child();          obj2.show();      } }

Output:

Parent's show()
Child's show()

Rules for method overriding:

1. Overriding and Access-Modifiers : The access modifier for an overriding method can allow more, but not less, access than the overridden method. For example, a protected instance method in the super-class can be made public, but not private, in the subclass. Doing so, will generate compile-time error.
   
   
   
   

   class Parent {           private void m1()      {          System.out.println( "From parent m1()" );      }        protected void m2()      {          System.out.println( "From parent m2()" );      } }   class Child extends Parent {                private void m1()      {          System.out.println( "From child m1()" );      }                  @Override      public void m2()      {          System.out.println( "From child m2()" );      } }   class Main {      public static void main(String[] args)      {          Parent obj1 = new Parent();          obj1.m2();          Parent obj2 = new Child();          obj2.m2();      } }

   Output:

   From parent m2()
   From child m2()
   

2. Final methods can not be overridden : If we don’t want a method to be overridden, we declare it as final. Please see Using final with Inheritance .
   
   
   
   

   class Parent {           final void show() {} }   class Child extends Parent {           void show() {} }

   Output:

   13: error: show() in Child cannot override show() in Parent
       void show() {  }
            ^
     overridden method is final
   

3. Static methods can not be overridden(Method Overriding vs Method Hiding) : When you define a static method with same signature as a static method in base class, it is known as method hiding. The following postpone summarizes what happens when you define a method with the same signature as a method in a super-class .
   

   	Superclass Instance Method	Superclass Static Method
   Subclass Instance Method	Overrides	Generates a compile-time error
   Subclass Static Method	Generates a compile-time error	Hides

   
   
   
   

   class Parent {                static void m1()      {          System.out.println( "From parent "                             + "static m1()" );      }                  void m2()      {          System.out.println( "From parent "                             + "non-static(instance) m2()" );      } }   class Child extends Parent {           static void m1()      {          System.out.println( "From child static m1()" );      }             @Override      public void m2()      {          System.out.println( "From child "                             + "non-static(instance) m2()" );      } }   class Main {      public static void main(String[] args)      {          Parent obj1 = new Child();                                                         obj1.m1();                              obj1.m2();      } }

   Output:

   From parent static m1()
   From child non-static(instance) m2()
   

4. Private methods can not be overridden : Private methods cannot be overridden as they are bonded during compile time. Therefore we can’t even override private methods in a subclass.(See this for details).
5. The overriding method must have same return type (or subtype) : From Java 5.0 onwards it is possible to have different return type for a overriding method in child class, but child’s return type should be sub-type of parent’s return type. This phenomena is known as covariant return type.
6. Invoking overridden method from sub-class : We can call parent class method in overriding method using super keyword.
   
   
   
   

   class Parent {      void show()      {          System.out.println( "Parent's show()" );      } }   class Child extends Parent {           @Override      void show()      {          super .show();          System.out.println( "Child's show()" );      } }   class Main {      public static void main(String[] args)      { Read more: How to block annoying ads using an ad blocker          Parent obj = new Child();          obj.show();      } }

   Output:

   Parent's show()
   Child's show()
   

7. Overriding and constructor : We can not override constructor as parent and child class can never have constructor with same name(Constructor name must always be same as Class name).
8. Overriding and Exception-Handling : Below are two rules to note when overriding methods related to exception-handling.
   • Rule#1 : If the super-class overridden method does not throw an exception, subclass overriding method can only throws the unchecked exception, throwing checked exception will lead to compile-time error.
     
     
     
     

     class Parent {      void m1()      {          System.out.println( "From parent m1()" );      }        void m2()      {          System.out.println( "From parent  m2()" );      } }   class Child extends Parent {      @Override           void m1() throws ArithmeticException      {          System.out.println( "From child m1()" );      }        @Override                void m2() throws Exception      {          System.out.println( "From child m2" );      } }

     Output:

     error: m2() in Child cannot override m2() in Parent
         void m2() throws Exception{ System.out.println("From child m2");}
              ^
       overridden method does not throw Exception
     

   • Rule#2 : If the super-class overridden method does throws an exception, subclass overriding method can only throw same, subclass exception. Throwing parent exception in Exception hierarchy will lead to compile time error.Also there is no issue if subclass overridden method is not throwing any exception.
     
     
     
     

     class Parent {      void m1() throws RuntimeException      {          System.out.println( "From parent m1()" );      } }   class Child1 extends Parent {      @Override           void m1() throws RuntimeException      {          System.out.println( "From child1 m1()" );      } } class Child2 extends Parent {      @Override           void m1() throws ArithmeticException      {          System.out.println( "From child2 m1()" );      } } class Child3 extends Parent {      @Override           void m1()      {          System.out.println( "From child3 m1()" );      } } class Child4 extends Parent {      @Override                void m1() throws Exception      {          System.out.println( "From child4 m1()" );      } }

     Output:

     error: m1() in Child4 cannot override m1() in Parent
         void m1() throws Exception
              ^
       overridden method does not throw Exception
     

9. Overriding and abstract method: Abstract methods in an interface or abstract class are meant to be overridden in derived concrete classes otherwise a compile-time error will be thrown.
10. Overriding and synchronized/strictfp method : The presence of synchronized/strictfp modifier with method have no effect on the rules of overriding, i.e. it’s possible that a synchronized/strictfp method can override a non synchronized/strictfp one and vice-versa.

Note :

1. In C++, we need virtual keyword to achieve overriding or Run Time Polymorphism. In Java, methods are virtual by default.
2. We can have multilevel method-overriding.
   
   
   
   

   class Parent {      void show()      {          System.out.println( "Parent's show()" );      } }   class Child extends Parent {           void show() { System.out.println( "Child's show()" ); } }   class GrandChild extends Child {           void show()      {          System.out.println( "GrandChild's show()" );      } }   class Main {      public static void main(String[] args)      {          Parent obj1 = new GrandChild();          obj1.show();      } }

   Output:

   GrandChild's show()
   

3. Overriding vs Overloading :
   
   1. Overloading is about same method have different signatures. Overriding is about same method, same signature but different classes connected through inheritance.
   2. Overloading is an example of compiler-time polymorphism and overriding is an example of run time polymorphism.

Why Method Overriding ?

As stated earlier, override methods allow Java to support run-time polymorphism. polymorphism is essential to object-oriented scheduling for one rationality : it allows a cosmopolitan class to specify methods that will be common to all of its derivatives while allowing subclasses to define the specific execution 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 herculean mechanisms that object-oriented purpose brings to bear on code recycle 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 brawny tool. Overridden methods allow us to call methods of any of the derive classes without even knowing the type of deduce class object. 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 which moves from lesser to greater specialization. Used correctly, the superclass provides all elements that a subclass can use directly. It besides defines those methods that the derive class must implement on its own. This allows the subclass the flexibility to define its methods, so far placid enforces a reproducible 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 virtual example that uses method overriding. Consider an employee management software for an organization, let the code has a simple base course Employee, the class has methods like raiseSalary ( ), transfer ( ), promote ( ), .. etc. Different types of employees like Manager, Engineer, ..etc may have their implementations of the methods portray in base class Employee. In our complete software, we just need to pass a tilt of employees everywhere and call allow methods without even knowing the type of employee. For exemplar, we can easily raise the wage of all employees by iterating through the number of employees. Every character of employee may have its logic in its class, we don ’ t need to worry because if raiseSalary ( ) is present for a specific employee character, merely that method acting would be called.

class Employee {      public static int base = 10000 ;      int salary()      {          return base;      } }   class Manager extends Employee {           int salary()      {          return base + 20000 ;      } }   class Clerk extends Employee {           int salary()      {          return base + 10000 ;      } }   class Main {                static void printSalary(Employee e)      {          System.out.println(e.salary());      }        public static void main(String[] args)      {          Employee obj1 = new Manager();                              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: This article is contributed by Twinkle Tyagi and Gaurav Miglani. If you like Flickroom and would like to contribute, you can besides write an article using write.geeksforgeeks.org or mail your article to review-team @ geeksforgeeks.org. See your article appearing on the Flickroom chief page and help other Geeks. Please write comments if you find anything incorrect, or you want to share more information about the subject discussed above. Attention subscriber ! Don ’ t discontinue determine now. Get delay of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry fix. To complete your formulation from learning a lyric to DS Algo and many more, please refer Complete Interview Preparation Course .

My Personal Notes

arrow_drop_up

Reservoir : https://flickroom.net
category : Web Browsers