Before we dive into the topic Method Overriding in Java extensively, let us look at a real-life example as always. Consider a family of three people, the father, the mother, and the son. The father decides to teach his son how to shoot. So he takes him to the range with his favorite rifle and trains him to aim at targets and shoot. However, the father is right-handed but the son is left-handed. So they have different methods of holding the gun! The father was worried that he might not be able to teach his son the art of shooting because of different orientations.<\/p>\n
The son, however, was smart and decided to mimic the father\u2019s hands by inverting them, i.e placing his dominant hand on the trigger rather than the father\u2019s dominant hand. i.e the right hand. In this way, by slightly altering the method of learning, the son mastered the art of shooting!<\/p>\n
This concept in programming is known as method overriding. Let us learn more about it.<\/p>\n
The concept of method overriding is simply the redefinition of the parent class method in the child class. The name of the method remains the same. However, the implementation of the same changes. Similar to the example above, the child class inherits all methods from the parent class Father.<\/p>\n
However, the method shoot() gets redefined. That way, the implementation of the method changes but the name still remains the same. This enables easier debugging and cleaner code.<\/p>\n
If the subclass provides a specific definition of a parent class method, then this action is Method Overloading.<\/strong><\/em><\/p>\n The primary advantage of method overriding is that the child class can have a different implementation of a parent class method without even changing the definition of the parent class method.<\/p>\n How is this useful?<\/strong><\/p>\n For example, if a parent class has multiple child classes, each child class can have its own implementation of the parent class method. Program to illustrate Java Method Overriding:<\/strong><\/p>\n Output:<\/p>\n Note that the dynamic method dispatch executes the child class method.<\/strong><\/em><\/p>\n In Java, you can also override methods while using multiple inheritance. The method in the parent class can be overridden in all of its successive child classes.<\/p>\n Program to illustrate the use of method overriding in multilevel inheritance in Java:<\/strong><\/p>\n Output:<\/p>\n Learning about the intricacies of method overriding and its actual implementation is crucial to developing good software. This prevents code redundancy and results in easy debugging because of good structure.<\/p>\n You should use method overriding when there is a need to implement a specific functionality of a child class that is unique to the class itself. But you might think, \u201cWhy not put it in a separate function altogether?\u201d Well, you are not the first one to think like that. But the same method can have different implementations in different classes, too!<\/p>\n Note the example above. You may realize that we could easily have made a different method for the class Child named \u201cshoot child()\u201d and written class-specific code there! But what we managed to do was keep the same name of the function as the parent class itself! That way, when you try to debug the code, and you realize that there is an error in the shoot() function, you can straightaway go to the class Child and debug your code inside the function. Having different names is tedious and difficult to maintain.<\/p>\n Method overriding becomes even more interesting in scenarios with multiple inheritance levels. Consider a class hierarchy where Child inherits from Parent, and GrandChild inherits from Child. In this case:<\/p>\n This cascaded overriding mechanism provides flexibility in inheritance hierarchies, allowing for specialized behavior in descendant classes.<\/p>\n The overriding has the following uses in Java:<\/strong><\/p>\n There are a few rules when it comes to implementing Method Overriding:<\/p>\n Okay, enough of the theory! Let us dive into some code!<\/p>\n Output:<\/strong><\/p>\n The private method in the above example is not printed because it is non-overridable.<\/p>\n If you override a static method in the parent class with the static method in the child class, then the method in the parent class hides the child class method. Let us see an example. However, if you try to override a static method from a non-static method context, or vice versa, the compiler returns an error.<\/p>\n Java program to illustrate static method overriding:<\/strong><\/p>\n Output:<\/p>\n If you have a method declared as final in your parent class, then that method is non-overridable. Let us see for ourselves.<\/p>\n Program to illustrate Java final method:<\/strong><\/p>\n Output:<\/strong><\/p>\n There are certain rules when it comes to using exception handling and method overriding. One of them is that if the superclass method does not throw any checked exceptions, then the subclass method can only throw unchecked exceptions. If it tries to throw checked exceptions, then the compiler returns an error.<\/p>\n Let us see with an example of handling exceptions and method overriding in Java:<\/p>\n Output:<\/strong><\/p>\n Points to Remember while using Method Overriding in Java<\/strong><\/p>\n If the parent class method throws a checked exception, then the child class method may or may not throw an exception at all. But if it does throw an exception, it must be the same exception or its subclass. However, if the parent exception is Exception Hierarchy, then a compile error occurs. Let us understand with an example:<\/p>\n Output:<\/strong><\/p>\n The super keyword is essential as it calls the parent constructor or a parent class method in the child class. In order to call the parent class constructor, we use super(),<\/strong> and for calling a superclass method named supermethod(),<\/strong> the syntax is super.supermethod(); <\/strong>Let us take a look at one example:<\/p>\n Java program to illustrate the use of super keyword:<\/strong><\/p>\n Output:<\/strong><\/p>\n Finally, in this article, we learned about the various types of method overriding and its uses in Java. Method overriding implements polymorphism in the language, which is essential to master. We also learned about the super keyword and the rules of method overriding.<\/p>\n","protected":false},"excerpt":{"rendered":" Before we dive into the topic Method Overriding in Java extensively, let us look at a real-life example as always. Consider a family of three people, the father, the mother, and the son. The...<\/p>\n","protected":false},"author":5,"featured_media":84357,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[32],"tags":[20915,7607,7627,20913,20914],"class_list":["post-7412","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-java-method-overriding-tutorial","tag-java-multilevel-method-overriding","tag-java-overridden-methods","tag-method-overriding-in-java-with-example","tag-method-overriding-rules-in-java"],"yoast_head":"\nAdvantages of Method Overriding in Java<\/h3>\n
\nHowever, when a parent class reference points to a child class object, the compiler resolves the object call during runtime. This is a dynamic method dispatch.<\/p>\npackage com.dataflair.javamethodoverriding;\r\nclass Father {\r\n void shoot() {\r\n System.out.println(\"I am the father! I am a right-handed shooter! \");\r\n }\r\n}\r\npublic class Child extends Father {\r\n void shoot() {\r\n System.out.println(\"I am the son! I am a left-handed shooter!\");\r\n }\r\n public static void main(String[] args) {\r\n Father f = new Father();\r\n f.shoot(); \/\/Here the parent class method gets called.\r\n Father fc = new Child();\r\n fc.shoot(); \/\/This is dynamic methpod dispatch. The compiler decides method call at runtime. \r\n }\r\n}<\/pre>\n
\nI am the son! I am a left-handed shooter!<\/div>\npackage com.dataflair.javamethodoverriding;\r\nclass GrandFather {\r\n void move() {\r\n System.out.println(\"I use my stick to move!\");\r\n }\r\n}\r\nclass Father extends GrandFather {\r\n void move() {\r\n System.out.println(\"I can walk fast!\");\r\n }\r\n}\r\nclass Baby extends Father {\r\n void move() {\r\n System.out.println(\"I crawl and have fun!\");\r\n }\r\n public static void main(String[] args) {\r\n GrandFather ob = new Baby();\r\n ob.move();\r\n\r\n }\r\n}<\/pre>\nWhen should you use Java method overriding?<\/h3>\n
Method Overriding in Inheritance Hierarchies<\/h3>\n
\n
Usage of Method Overriding in Java<\/h3>\n
\n
Rules to follow while implementing Java Method Overriding<\/h3>\n
\n
Method Overriding with Access Specifiers in Java<\/h3>\n
package com.dataflair.javamethodoverriding;\r\nclass Father {\r\n \/\/ private methods are not overridden \r\n private void method1() {\r\n System.out.println(\"From Father method1()\");\r\n }\r\n\r\n protected void method2() {\r\n System.out.println(\"From Father method2()\");\r\n }\r\n}\r\n\r\nclass Child extends Father {\r\n \/\/ new method1() method \r\n \/\/ This method is unique to Child class \r\n private void method1() {\r\n System.out.println(\"From Child method1()\");\r\n }\r\n\r\n \/\/ overriding method \r\n \/\/ with greater accessibility \r\n public void method2() {\r\n System.out.println(\"From Child method2()\");\r\n }\r\n}\r\n\r\n\/\/ Driver class \r\nclass Main {\r\n public static void main(String[] args) {\r\n Father obj1 = new Father();\r\n obj1.method2();\r\n Father obj2 = new Child();\r\n obj2.method2();\r\n }\r\n}<\/pre>\n
\nFrom Child method2()<\/div>\nStatic methods in Java are non-overridable<\/h3>\n
package com.dataflair.javamethodoverriding;\r\nclass Father {\r\n \/\/ private methods are not overridden \r\n static void method1() {\r\n System.out.println(\"From static Father method1()\");\r\n }\r\n\r\n void method2() {\r\n System.out.println(\"From Father method2()\");\r\n }\r\n}\r\n\r\nclass Child extends Father {\r\n \/\/ new method1() method \r\n \/\/ This method is unique to Child class \r\n static void method1() {\r\n System.out.println(\"From static Child method1()\");\r\n }\r\n\r\n \/\/ overriding method \r\n \/\/ with greater accessibility \r\n void method2() {\r\n System.out.println(\"From Child method2()\");\r\n }\r\n}\r\n\r\n\/\/ Driver class \r\nclass StaticOverride {\r\n public static void main(String[] args) {\r\n Father obj1 = new Father();\r\n obj1.method2();\r\n Father obj2 = new Child();\r\n obj2.method1(); \/\/According to dynamic method dispatch this should execute child class method but this executes parent class method. \r\n }\r\n}<\/pre>\n
\nFrom static Father method1()<\/div>\nYou cannot override final methods in Java<\/h3>\n
package com.dataflair.javamethodoverriding;\r\nclass Father {\r\n final void shoot() {\r\n System.out.println(\"I am the father! I am a right handed shooter! \");\r\n }\r\n}\r\npublic class Child extends Father {\r\n void shoot() {\r\n super.shoot();\r\n System.out.println(\"I am the son! I am a left handed shooter!\");\r\n }\r\n public static void main(String[] args) {\r\n\r\n Father fc = new Child();\r\n fc.shoot(); \/\/This is the method which houses the super keyword for calling the parent class method. \r\n }\r\n}<\/pre>\n
\nvoid shoot()
\n^
\noverridden method is final
\n1 error<\/div>\nException Handling and Method Overriding in Java<\/h3>\n
package com.dataflair.javamethodoverriding;\r\nclass Parent {\r\n void methodname() {\r\n System.out.println(\"I do not have any checked excpetions.\");\r\n }\r\n}\r\nclass Child extends Parent {\r\n void methodname() throws IOException {\r\n System.out.println(\"I throw checked exceptions\");\r\n }\r\n}\r\npublic class MainException {\r\n public static void main(String[] args) {\r\n\r\n Parent p = new Child();\r\n p.methodname();\r\n }\r\n\r\n}<\/pre>\n
\nvoid methodname()throws IOException
\n^The
\noverridden method does not throw IOException
\n2 errors<\/div>\npackage com.dataflair.javamethodoverriding;\r\nimport java.io. * ;\r\nclass Parent {\r\n void methodname() throws IOException {\r\n System.out.println(\"I do not have any checked excpetions.\");\r\n }\r\n}\r\nclass Child1 extends Parent {\r\n void methodname() throws IOException {\r\n System.out.println(\"I throw checked exceptions\");\r\n }\r\n}\r\nclass Child2 extends Parent {\r\n void methodname() throws Exception {\r\n System.out.println(\"Exception Hierarchy\");\r\n }\r\n}\r\npublic class MainException {\r\n public static void main(String[] args) {\r\n\r\n Parent p = new Child1();\r\n p.methodname();\r\n Parent p1 = new Child2();\r\n p1.methodname();\r\n }\r\n\r\n}<\/pre>\n
\nvoid methodname()throws Exception{
\n^The
\noverridden method does not throw an exception
\n1 error<\/div>\nSuper Keyword in Java<\/h3>\n
package com.dataflair.javamethodoverriding;\r\nclass Father {\r\n void shoot() {\r\n System.out.println(\"I am the father! I am a right-handed shooter! \");\r\n }\r\n}\r\npublic class Child extends Father {\r\n void shoot() {\r\n super.shoot(); \/\/This super keyword calls the method with the same name in the parent class. \r\n System.out.println(\"I am the son! I am a left-handed shooter!\");\r\n }\r\n public static void main(String[] args) {\r\n\r\n Father fc = new Child();\r\n fc.shoot(); \/\/This is the method which houses the super keyword for calling the parent class method. \r\n }\r\n}<\/pre>\n
\nI am the son! I am a left-handed shooter!<\/div>\nSummary<\/h3>\n