Here, in this class OverloadingDemo we defined two constructors with different signatures, and three methods with same name but different number and/or types of passing parameters.

Overriding:

     Overriding is the technique of inheriting a class and redefining the behaviors of the super class. That means, when you define a method in subclass with the same signature (name, plus the number and the type of its parameters) and return type as in the superclass, then you are overriding the method of the superclass in your subclass, and the technique is known as method overriding.
   

           In method overriding, method name, method input parameters and return types in subclass should be same in superclass.  It can only modify the behaviors. It can return a subtype of the original return type defined in superclass, and this technique is known as covariant return type [Java 1.5 or above support this]. For example, suppose the return type in superclass is java.util.Map, you can change it to java.util.HashMap in subclass, as HashMap is a subtype of Map.

           You can also use @Override annotation [which is available in Java 1.5 or above] to tell the compiler that you are trying to override a method in the superclass. And, fof any reason, if the compile is unable to detect that method, it will generate an error.

            In method overriding in java, you can level up the access level but you can’t level it down. That means, if a method is declared as protected in superclass, it can be set as public is subclass but not as private.

             If a method is declared as final, it can’t be overridden.

Now let’s see with an example.

Code:

Super Class :

Sub Class:

package com.interview.question.java;

import java.util.HashMap;

import java.util.Map;

            public class OverridingDemo extends SuperClass{

                  /**

                *

                * This class demonstrates overriding by extending SuperClass

                *

                * @author http://interviewquestionjava.blogspot.com

                *

                **/

                 

                  /* Overriding with covariant return type :

                   * the return type of this method is modified to its subtype which is allowed in method overriding */

                  @Override

                public HashMap methodForcovariant(){

                        HashMap hmp = new HashMap();

                        return hmp;

                  }

                 

                  /* Overriding:

                   * overriding the method SuperClass.sampleMethod() */

                  @Override

                  public void sampleMethod(){

                  System.out.println("OverridingDemo.sampleMethod()");

                }

                 

                 

                  /* Overriding access specifier:

                   * the specifier of this method is changed to public from protected */

                  @Override

                public void protectedMethod(){

                  System.out.println("OverridingDemo.protectedMethod()");

                }

                 

           

            public static void main(String[] args) {

                 

                  SuperClass objSuperClass = new SuperClass();

                  SuperClass objOverridingDemo = new OverridingDemo();

                  objSuperClass.sampleMethod();

                  objOverridingDemo.sampleMethod();

                 

            }

                 

     

}

Output:

SuperClass.sampleMethod()

OverridingDemo.sampleMethod()

Here, we have used 4 methods:

methodForcovariant() – it shows the change of return type to its subtype during method overriding.

sampleMethod() – it shows method overriding in normal way.

protectedMethod() – it shows method overriding by leveling up access specifiers.

finalMethod() – it shows we can’t override methods declared as final.