1. Different ways to overload the method
2. By changing the no. of arguments
3. By changing the datatype
4. Why method overloading is not possible by changing the return type
5. Can we overload the main method
6. method overloading with Type Promotion

If a class has multiple methods having same name but different in parameters, it is known as Method Overloading.

If we have to perform only one operation, having same name of the methods increases the readability of the program.

Suppose you have to perform addition of the given numbers but there can be any number of arguments, if you write the method such as a(int,int) for two parameters, and b(int,int,int) for three parameters then it may be difficult for you as well as other programmers to understand the behavior of the method because its name differs.

So, we perform method overloading to figure out the program quickly.

Method overloading increases the readability of the program.

There are two ways to overload the method in java

1. By changing number of arguments
2. By changing the data type

In this example, we have created two methods, first add() method performs addition of two numbers and second add method performs addition of three numbers.

In this example, we are creating static methods so that we don't need to create instance for calling methods.

1. class Adder{  
2. static int add(int a,int b){return a+b;}  
3. static int add(int a,int b,int c){return a+b+c;}  
4. }  
5. class TestOverloading1{  
6. public static void main(String[] args){  
7. System.out.println(Adder.add(11,11));  
8. System.out.println(Adder.add(11,11,11));  
9. }}  

Test it Now

Output:

22

33

In this example, we have created two methods that differs in data type. The first add method receives two integer arguments and second add method receives two double arguments.

1. class Adder{  
2. static int add(int a, int b){return a+b;}  
3. static double add(double a, double b){return a+b;}  
4. }  
5. class TestOverloading2{  
6. public static void main(String[] args){  
7. System.out.println(Adder.add(11,11));  
8. System.out.println(Adder.add(12.3,12.6));  
9. }}  

Test it Now

Output:

22

24.9

In java, method overloading is not possible by changing the return type of the method only because of ambiguity. Let's see how ambiguity may occur:

1. class Adder{  
2. static int add(int a,int b){return a+b;}  
3. static double add(int a,int b){return a+b;}  
4. }  
5. class TestOverloading3{  
6. public static void main(String[] args){  
7. System.out.println(Adder.add(11,11));//ambiguity 
8. }}  

Test it Now

Output:

Compile Time Error: method add(int,int) is already defined in class Adder

System.out.println(Adder.add(11,11)); //Here, how can java determine which sum() method should be called?

Yes, by method overloading. You can have any number of main methods in a class by method overloading. But JVM calls main() method which receives string array as arguments only. Let's see the simple example:

1. class TestOverloading4{  
2. public static void main(String[] args){System.out.println("main with String[]");}  
3. public static void main(String args){System.out.println("main with String");}  
4. public static void main(){System.out.println("main without args");}  
5. }  

Test it Now

Output:

main with String[]

One type is promoted to another implicitly if no matching datatype is found. Let's understand the concept by the figure given below:

ADAD

As displayed in the above diagram, byte can be promoted to short, int, long, float or double. The short datatype can be promoted to int, long, float or double. The char datatype can be promoted to int,long,float or double and so on.

1. class OverloadingCalculation1{  
2. void sum(int a,long b){System.out.println(a+b);}  
3. void sum(int a,int b,int c){System.out.println(a+b+c);}  
4. public static void main(String args[]){  
5.   OverloadingCalculation1 obj=new OverloadingCalculation1();  
6.   obj.sum(20,20);//now second int literal will be promoted to long 
7.   obj.sum(20,20,20);  
8.   }  
9. }  

Test it Now

Output:40

       60

If there are matching type arguments in the method, type promotion is not performed.

1. class OverloadingCalculation2{  
2. void sum(int a,int b){System.out.println("int arg method invoked");}  
3. void sum(long a,long b){System.out.println("long arg method invoked");}  
4. public static void main(String args[]){  
5.   OverloadingCalculation2 obj=new OverloadingCalculation2();  
6.   obj.sum(20,20);//now int arg sum() method gets invoked 
7.   }  
8. }  

Test it Now

Output:int arg method invoked

If there are no matching type arguments in the method, and each method promotes similar number of arguments, there will be ambiguity.

1. class OverloadingCalculation3{  
2. void sum(int a,long b){System.out.println("a method invoked");}  
3. void sum(long a,int b){System.out.println("b method invoked");}  
4. public static void main(String args[]){  
5.   OverloadingCalculation3 obj=new OverloadingCalculation3();  
6.   obj.sum(20,20);//now ambiguity 
7.   }  
8. }  

Test it Now

Output:Compile Time Error

       

============================================================================== 

1. Understanding the problem without method overriding
2. Can we override the static method
3. Method overloading vs. method overriding

If subclass (child class) has the same method as declared in the parent class, it is known as method overriding in Java.

In other words, If a subclass provides the specific implementation of the method that has been declared by one of its parent class, it is known as method overriding.

• Method overriding is used to provide the specific implementation of a method which is already provided by its superclass.
• Method overriding is used for runtime polymorphism

1. The method must have the same name as in the parent class
2. The method must have the same parameter as in the parent class.
3. There must be an IS-A relationship (inheritance).

Let's understand the problem that we may face in the program if we don't use method overriding.

1. //Java Program to demonstrate why we need method overriding 
2. //Here, we are calling the method of parent class with child 
3. //class object. 
4. //Creating a parent class 
5. class Vehicle{  
6. void run(){System.out.println("Vehicle is running");}  
7. }  
8. //Creating a child class 
9. class Bike extends Vehicle{  
10. public static void main(String args[]){  
11. //creating an instance of child class 
12.   Bike obj = new Bike();  
13. //calling the method with child class instance 
14.   obj.run();  
15.   }  
16. }  

Test it Now

Output:

Vehicle is running

Problem is that I have to provide a specific implementation of run() method in subclass that is why we use method overriding.

In this example, we have defined the run method in the subclass as defined in the parent class but it has some specific implementation. The name and parameter of the method are the same, and there is IS-A relationship between the classes, so there is method overriding.

1. //Java Program to illustrate the use of Java Method Overriding 
2. //Creating a parent class. 
3. class Vehicle{  
4. //defining a method 
5. void run(){System.out.println("Vehicle is running");}  
6. }  
7. //Creating a child class 
8. class Bike2 extends Vehicle{  
9. //defining the same method as in the parent class 
10. void run(){System.out.println("Bike is running safely");}  
11. public static void main(String args[]){  
12.   Bike2 obj = new Bike2();//creating object 
13.   obj.run();//calling method 
14.   }  
15. }  

Test it Now

Output:

Bike is running safely

Consider a scenario where Bank is a class that provides functionality to get the rate of interest. However, the rate of interest varies according to banks. For example, SBI, ICICI and AXIS banks could provide 8%, 7%, and 9% rate of interest.

1. //Java Program to demonstrate the real scenario of Java Method Overriding 
2. //where three classes are overriding the method of a parent class. 
3. //Creating a parent class. 
4. class Bank{  
5. int getRateOfInterest(){return 0;}  
6. }  
7. //Creating child classes. 
8. class SBI extends Bank{  
9. int getRateOfInterest(){return 8;}  
10. }  
11. class ICICI extends Bank{  
12. int getRateOfInterest(){return 7;}  
13. }  
14. class AXIS extends Bank{  
15. int getRateOfInterest(){return 9;}  
16. }  
17. //Test class to create objects and call the methods 
18. class Test2{  
19. public static void main(String args[]){  
20. SBI s=new SBI();  
21. ICICI i=new ICICI();  
22. AXIS a=new AXIS();  
23. System.out.println("SBI Rate of Interest: "+s.getRateOfInterest());  
24. System.out.println("ICICI Rate of Interest: "+i.getRateOfInterest());  
25. System.out.println("AXIS Rate of Interest: "+a.getRateOfInterest());  
26. }  
27. }  

Test it Now

Output:

SBI Rate of Interest: 8

ICICI Rate of Interest: 7

AXIS Rate of Interest: 9

No, a static method cannot be overridden. It can be proved by runtime polymorphism, so we will learn it later.

It is because the static method is bound with class whereas instance method is bound with an object. Static belongs to the class area, and an instance belongs to the heap area.

No, because the main is a static method.

Click me for the difference between method overloading and overriding

Method Overriding with Access Modifier

Let's see the concept of method overriding with access modifier.

Exception Handling with Method Overriding

Let's see the concept of method overriding with exception handling.
 

============================================================================== 

The covariant return type specifies that the return type may vary in the same direction as the subclass.

Before Java5, it was not possible to override any method by changing the return type. But now, since Java5, it is possible to override method by changing the return type if subclass overrides any method whose return type is Non-Primitive but it changes its return type to subclass type. Let's take a simple example:

FileName: B1.java

1. class A{    
2. A get(){return this;}    
3. }    
4. class B1 extends A{    
5. @Override 
6. B1 get(){return this;}    
7. void message(){System.out.println("welcome to covariant return type");}    
8. public static void main(String args[]){    
9. new B1().get().message();    
10. }    
11. }    

Test it Now

Output:

welcome to covariant return type

As you can see in the above example, the return type of the get() method of A class is A but the return type of the get() method of B class is B. Both methods have different return type but it is method overriding. This is known as covariant return type.

Following are the advantages of the covariant return type.

1) Covariant return type assists to stay away from the confusing type casts in the class hierarchy and makes the code more usable, readable, and maintainable.

2) In the method overriding, the covariant return type provides the liberty to have more to the point return types.

3) Covariant return type helps in preventing the run-time ClassCastExceptions on returns.

Let's take an example to understand the advantages of the covariant return type.

FileName: CovariantExample.java

1. class A1  
2. {  
3.     A1 foo()  
4.     {  
5. return this;  
6.     }  
7. void print()  
8.     {  
9.         System.out.println("Inside the class A1");  
10.     }  
11. }  
12. // A2 is the child class of A1 
13. class A2 extends A1  
14. {  
15. @Override 
16.     A1 foo()  
17.     {  
18. return this;  
19.     }  
20. void print()  
21.     {  
22.         System.out.println("Inside the class A2");  
23.     }  
24. }  
25. // A3 is the child class of A2 
26. class A3 extends A2  
27. {  
28. @Override 
29.     A1 foo()  
30.     {  
31. return this;  
32.     }  
33. @Override 
34. void print()  
35.     {  
36.         System.out.println("Inside the class A3");  
37.     }  
38. }  
39. public class CovariantExample  
40. {  
41. // main method 
42. public static void main(String argvs[])  
43.     {  
44.        A1 a1 = new A1();  
45. // this is ok 
46.        a1.foo().print();  
47.        A2 a2 = new A2();  
48. // we need to do the type casting to make it  
49. // more clear to reader about the kind of object created  
50.        ((A2)a2.foo()).print();  
51.        A3 a3 = new A3();  
52. // doing the type casting 
53.        ((A3)a3.foo()).print();  
54.     }  
55. }  

Output:

Inside the class A1

Inside the class A2

Inside the class A3

Explanation: In the above program, class A3 inherits class A2, and class A2 inherits class A1. Thus, A1 is the parent of classes A2 and A3. Hence, any object of classes A2 and A3 is also of type A1. As the return type of the method foo() is the same in every class, we do not know the exact type of object the method is actually returning. We can only deduce that returned object will be of type A1, which is the most generic class. We can not say for sure that returned object will be of A2 or A3. It is where we need to do the typecasting to find out the specific type of object returned from the method foo(). It not only makes the code verbose; it also requires precision from the programmer to ensure that typecasting is done properly; otherwise, there are fair chances of getting the ClassCastException. To exacerbate it, think of a situation where the hierarchical structure goes down to 10 - 15 classes or even more, and in each class, the method foo() has the same return type. That is enough to give a nightmare to the reader and writer of the code.

The better way to write the above is:

FileName: CovariantExample.java

1. class A1  
2. {  
3.     A1 foo()  
4.     {  
5. return this;  
6.     }  
7. void print()  
8.     {  
9.         System.out.println("Inside the class A1");  
10.     }  
11. }  
12. // A2 is the child class of A1 
13. class A2 extends A1  
14. {  
15. @Override 
16.     A2 foo()  
17.     {  
18. return this;  
19.     }  
20. void print()  
21.     {  
22.         System.out.println("Inside the class A2");  
23.     }  
24. }  
25. // A3 is the child class of A2 
26. class A3 extends A2  
27. {  
28. @Override 
29.     A3 foo()  
30.     {  
31. return this;  
32.     }  
33. @Override 
34. void print()  
35.     {  
36.         System.out.println("Inside the class A3");  
37.     }  
38. }  
39. public class CovariantExample  
40. {  
41. // main method 
42. public static void main(String argvs[])  
43.     {  
44.        A1 a1 = new A1();  
45.        a1.foo().print();  
46.        A2 a2 = new A2();  
47.        a2.foo().print();  
48.        A3 a3 = new A3();  
49.        a3.foo().print();  
50.     }  
51. }  

Output:

Inside the class A1

Inside the class A2

Inside the class A3

Explanation: In the above program, no typecasting is needed as the return type is specific. Hence, there is no confusion about knowing the type of object getting returned from the method foo(). Also, even if we write the code for the 10 - 15 classes, there would be no confusion regarding the return types of the methods. All this is possible because of the covariant return type.

ADAD

Java doesn't allow the return type-based overloading, but JVM always allows return type-based overloading. JVM uses the full signature of a method for lookup/resolution. Full signature means it includes return type in addition to argument types. i.e., a class can have two or more methods differing only by return type. javac uses this fact to implement covariant return types.

Output:

The number 1 is not the powerful number.

The number 2 is not the powerful number.

The number 3 is not the powerful number.

The number 4 is the powerful number.

The number 5 is not the powerful number.

The number 6 is not the powerful number.

The number 7 is not the powerful number.

The number 8 is the powerful number.

The number 9 is the powerful number.

The number 10 is not the powerful number.

The number 11 is not the powerful number.

The number 12 is not the powerful number.

The number 13 is not the powerful number.

The number 14 is not the powerful number.

The number 15 is not the powerful number.

The number 16 is the powerful number.

The number 17 is not the powerful number.

The number 18 is not the powerful number.

The number 19 is not the powerful number.

The number 20 is the powerful number.

Explanation: For every number from 1 to 20, the method isPowerfulNo() is invoked with the help of for-loop. For every number, a vector primeFactors is created for storing its prime divisors. Then, we check whether square of every number present in the vector primeFactors divides the number or not. If all square of all the number present in the vector primeFactors divides the number completely, the number is a powerful number; otherwise, not.

============================================================================== 

The super keyword in Java is a reference variable which is used to refer immediate parent class object.

Whenever you create the instance of subclass, an instance of parent class is created implicitly which is referred by super reference variable.

1. super can be used to refer immediate parent class instance variable.
2. super can be used to invoke immediate parent class method.
3. super() can be used to invoke immediate parent class constructor.

We can use super keyword to access the data member or field of parent class. It is used if parent class and child class have same fields.

1. class Animal{  
2. String color="white";  
3. }  
4. class Dog extends Animal{  
5. String color="black";  
6. void printColor(){  
7. System.out.println(color);//prints color of Dog class 
8. System.out.println(super.color);//prints color of Animal class 
9. }  
10. }  
11. class TestSuper1{  
12. public static void main(String args[]){  
13. Dog d=new Dog();  
14. d.printColor();  
15. }}  

Test it Now

Output:

black

white

In the above example, Animal and Dog both classes have a common property color. If we print color property, it will print the color of current class by default. To access the parent property, we need to use super keyword.

The super keyword can also be used to invoke parent class method. It should be used if subclass contains the same method as parent class. In other words, it is used if method is overridden.

1. class Animal{  
2. void eat(){System.out.println("eating...");}  
3. }  
4. class Dog extends Animal{  
5. void eat(){System.out.println("eating bread...");}  
6. void bark(){System.out.println("barking...");}  
7. void work(){  
8. super.eat();  
9. bark();  
10. }  
11. }  
12. class TestSuper2{  
13. public static void main(String args[]){  
14. Dog d=new Dog();  
15. d.work();  
16. }}  

Test it Now

Output:

eating...

barking...

In the above example Animal and Dog both classes have eat() method if we call eat() method from Dog class, it will call the eat() method of Dog class by default because priority is given to local.

To call the parent class method, we need to use super keyword.

ADAD

The super keyword can also be used to invoke the parent class constructor. Let's see a simple example:

1. class Animal{  
2. Animal(){System.out.println("animal is created");}  
3. }  
4. class Dog extends Animal{  
5. Dog(){  
6. super();  
7. System.out.println("dog is created");  
8. }  
9. }  
10. class TestSuper3{  
11. public static void main(String args[]){  
12. Dog d=new Dog();  
13. }}  

Test it Now

Output:

animal is created

dog is created

As we know well that default constructor is provided by compiler automatically if there is no constructor. But, it also adds super() as the first statement.

Another example of super keyword where super() is provided by the compiler implicitly.

1. class Animal{  
2. Animal(){System.out.println("animal is created");}  
3. }  
4. class Dog extends Animal{  
5. Dog(){  
6. System.out.println("dog is created");  
7. }  
8. }  
9. class TestSuper4{  
10. public static void main(String args[]){  
11. Dog d=new Dog();  
12. }}  

Test it Now

Output:

animal is created

dog is created

Let's see the real use of super keyword. Here, Emp class inherits Person class so all the properties of Person will be inherited to Emp by default. To initialize all the property, we are using parent class constructor from child class. In such way, we are reusing the parent class constructor.

1. class Person{  
2. int id;  
3. String name;  
4. Person(int id,String name){  
5. this.id=id;  
6. this.name=name;  
7. }  
8. }  
9. class Emp extends Person{  
10. float salary;  
11. Emp(int id,String name,float salary){  
12. super(id,name);//reusing parent constructor 
13. this.salary=salary;  
14. }  
15. void display(){System.out.println(id+" "+name+" "+salary);}  
16. }  
17. class TestSuper5{  
18. public static void main(String[] args){  
19. Emp e1=new Emp(1,"ankit",45000f);  
20. e1.display();  
21. }}  

Test it Now

Output:

1 ankit 45000

============================================================================== 

1. Instance initializer block
2. Example of Instance initializer block
3. What is invoked firstly instance initializer block or constructor?
4. Rules for instance initializer block
5. Program of instance initializer block that is invoked after super()

Instance Initializer block is used to initialize the instance data member. It run each time when object of the class is created.The initialization of the instance variable can be done directly but there can be performed extra operations while initializing the instance variable in the instance initializer block.

1. class Bike{  
2. int speed=100;  
3. }  

Suppose I have to perform some operations while assigning value to instance data member e.g. a for loop to fill a complex array or error handling etc.

Let's see the simple example of instance initializer block that performs initialization.

1. class Bike7{  
2. int speed;  
3.     Bike7(){System.out.println("speed is "+speed);}  
4.     {speed=100;}  
5. public static void main(String args[]){  
6.     Bike7 b1=new Bike7();  
7.     Bike7 b2=new Bike7();  
8.     }      
9. }  

Test it Now

Output:speed is 100

       speed is 100

 

There are three places in java where you can perform operations:

1. method
2. constructor
3. block

1. class Bike8{  
2. int speed;  
3.     Bike8(){System.out.println("constructor is invoked");}  
4.     {System.out.println("instance initializer block invoked");}  
5. public static void main(String args[]){  
6.     Bike8 b1=new Bike8();  
7.     Bike8 b2=new Bike8();  
8.     }      
9. }  

Test it Now

Output:instance initializer block invoked

       constructor is invoked

       instance initializer block invoked

       constructor is invoked

In the above example, it seems that instance initializer block is firstly invoked but NO. Instance intializer block is invoked at the time of object creation. The java compiler copies the instance initializer block in the constructor after the first statement super(). So firstly, constructor is invoked. Let's understand it by the figure given below:

There are mainly three rules for the instance initializer block. They are as follows:

1. The instance initializer block is created when instance of the class is created.
2. The instance initializer block is invoked after the parent class constructor is invoked (i.e. after super() constructor call).
3. The instance initializer block comes in the order in which they appear.

ADAD

1. class A{  
2. A(){  
3. System.out.println("parent class constructor invoked");  
4. }  
5. }  
6. class B2 extends A{  
7. B2(){  
8. super();  
9. System.out.println("child class constructor invoked");  
10. }  
11. {System.out.println("instance initializer block is invoked");}  
12. public static void main(String args[]){  
13. B2 b=new B2();  
14. }  
15. }  

Test it Now

Output:parent class constructor invoked

       instance initializer block is invoked

       child class constructor invoked

1. class A{  
2. A(){  
3. System.out.println("parent class constructor invoked");  
4. }  
5. }  
6. class B3 extends A{  
7. B3(){  
8. super();  
9. System.out.println("child class constructor invoked");  
10. }  
11. B3(int a){  
12. super();  
13. System.out.println("child class constructor invoked "+a);  
14. }  
15. {System.out.println("instance initializer block is invoked");}  
16. public static void main(String args[]){  
17. B3 b1=new B3();  
18. B3 b2=new B3(10);  
19. }  
20. }  

Test it Now

      parent class constructor invoked

       instance initializer block is invoked

       child class constructor invoked

       parent class constructor invoked

       instance initializer block is invoked

       child class constructor invoked 10

============================================================================== 

1. Final variable
2. Final method
3. Final class
4. Is final method inherited ?
5. Blank final variable
6. Static blank final variable
7. Final parameter
8. Can you declare a final constructor

The final keyword in java is used to restrict the user. The java final keyword can be used in many context. Final can be:

1. variable
2. method
3. class

The final keyword can be applied with the variables, a final variable that have no value it is called blank final variable or uninitialized final variable. It can be initialized in the constructor only. The blank final variable can be static also which will be initialized in the static block only. We will have detailed learning of these. Let's first learn the basics of final keyword.

If you make any variable as final, you cannot change the value of final variable(It will be constant).

There is a final variable speedlimit, we are going to change the value of this variable, but It can't be changed because final variable once assigned a value can never be changed.

1. class Bike9{  
2. final int speedlimit=90;//final variable 
3. void run(){  
4.   speedlimit=400;  
5.  }  
6. public static void main(String args[]){  
7.  Bike9 obj=new  Bike9();  
8.  obj.run();  
9.  }  
10. }//end of class 

Test it Now

Output:Compile Time Error

If you make any method as final, you cannot override it.

1. class Bike{  
2. final void run(){System.out.println("running");}  
3. }  
4. class Honda extends Bike{  
5. void run(){System.out.println("running safely with 100kmph");}  
6. public static void main(String args[]){  
7.    Honda honda= new Honda();  
8.    honda.run();  
9.    }  
10. }  

Test it Now

Output:Compile Time Error

If you make any class as final, you cannot extend it.

1. final class Bike{}  
2. class Honda1 extends Bike{  
3. void run(){System.out.println("running safely with 100kmph");}  
4. public static void main(String args[]){  
5.   Honda1 honda= new Honda1();  
6.   honda.run();  
7.   }  
8. }  

Test it Now

Output:Compile Time Error

Ans) Yes, final method is inherited but you cannot override it. For Example:

1. class Bike{  
2. final void run(){System.out.println("running...");}  
3. }  
4. class Honda2 extends Bike{  
5. public static void main(String args[]){  
6. new Honda2().run();  
7.    }  
8. }  

Test it Now

Output:running...

A final variable that is not initialized at the time of declaration is known as blank final variable.

If you want to create a variable that is initialized at the time of creating object and once initialized may not be changed, it is useful. For example PAN CARD number of an employee.

It can be initialized only in constructor.

1. class Student{  
2. int id;  
3. String name;  
4. final String PAN_CARD_NUMBER;  
5. ...  
6. }  

Yes, but only in constructor. For example:

1. class Bike10{  
2. final int speedlimit;//blank final variable 
3.   Bike10(){  
4.   speedlimit=70;  
5.   System.out.println(speedlimit);  
6.   }  
7. public static void main(String args[]){  
8. new Bike10();  
9.  }  
10. }  

Test it Now

Output: 70

A static final variable that is not initialized at the time of declaration is known as static blank final variable. It can be initialized only in static block.

1. class A{  
2. static final int data;//static blank final variable 
3. static{ data=50;}  
4. public static void main(String args[]){  
5.     System.out.println(A.data);  
6.  }  
7. }  

If you declare any parameter as final, you cannot change the value of it.

1. class Bike11{  
2. int cube(final int n){  
3.    n=n+2;//can't be changed as n is final 
4.    n*n*n;  
5.   }  
6. public static void main(String args[]){  
7.     Bike11 b=new Bike11();  
8.     b.cube(5);  
9.  }  
10. }  

Test it Now

Output: Compile Time Error

No, because constructor is never inherited.  

============================================================================== 

Polymorphism in Java is a concept by which we can perform a single action in different ways. Polymorphism is derived from 2 Greek words: poly and morphs. The word "poly" means many and "morphs" means forms. So polymorphism means many forms.

There are two types of polymorphism in Java: compile-time polymorphism and runtime polymorphism. We can perform polymorphism in java by method overloading and method overriding.

If you overload a static method in Java, it is the example of compile time polymorphism. Here, we will focus on runtime polymorphism in java.

Runtime polymorphism or Dynamic Method Dispatch is a process in which a call to an overridden method is resolved at runtime rather than compile-time.

In this process, an overridden method is called through the reference variable of a superclass. The determination of the method to be called is based on the object being referred to by the reference variable.

Let's first understand the upcasting before Runtime Polymorphism.

If the reference variable of Parent class refers to the object of Child class, it is known as upcasting. For example:

1. class A{}  
2. class B extends A{}  
3. A a=new B();//upcasting 

For upcasting, we can use the reference variable of class type or an interface type. For Example:

1. interface I{}  
2. class A{}  
3. class B extends A implements I{}  

Here, the relationship of B class would be:

B IS-A A

B IS-A I

B IS-A Object

Since Object is the root class of all classes in Java, so we can write B IS-A Object.

In this example, we are creating two classes Bike and Splendor. Splendor class extends Bike class and overrides its run() method. We are calling the run method by the reference variable of Parent class. Since it refers to the subclass object and subclass method overrides the Parent class method, the subclass method is invoked at runtime.

Since method invocation is determined by the JVM not compiler, it is known as runtime polymorphism.

1. class Bike{  
2. void run(){System.out.println("running");}  
3. }  
4. class Splendor extends Bike{  
5. void run(){System.out.println("running safely with 60km");}  
6. public static void main(String args[]){  
7.     Bike b = new Splendor();//upcasting 
8.     b.run();  
9.   }  
10. }  

Test it Now

Output:

running safely with 60km.

Consider a scenario where Bank is a class that provides a method to get the rate of interest. However, the rate of interest may differ according to banks. For example, SBI, ICICI, and AXIS banks are providing 8.4%, 7.3%, and 9.7% rate of interest.

1. class Bank{  
2. float getRateOfInterest(){return 0;}  
3. }  
4. class SBI extends Bank{  
5. float getRateOfInterest(){return 8.4f;}  
6. }  
7. class ICICI extends Bank{  
8. float getRateOfInterest(){return 7.3f;}  
9. }  
10. class AXIS extends Bank{  
11. float getRateOfInterest(){return 9.7f;}  
12. }  
13. class TestPolymorphism{  
14. public static void main(String args[]){  
15. Bank b;  
16. b=new SBI();  
17. System.out.println("SBI Rate of Interest: "+b.getRateOfInterest());  
18. b=new ICICI();  
19. System.out.println("ICICI Rate of Interest: "+b.getRateOfInterest());  
20. b=new AXIS();  
21. System.out.println("AXIS Rate of Interest: "+b.getRateOfInterest());  
22. }  
23. }  

Test it Now

Output:

SBI Rate of Interest: 8.4

ICICI Rate of Interest: 7.3

AXIS Rate of Interest: 9.7

1. class Shape{  
2. void draw(){System.out.println("drawing...");}  
3. }  
4. class Rectangle extends Shape{  
5. void draw(){System.out.println("drawing rectangle...");}  
6. }  
7. class Circle extends Shape{  
8. void draw(){System.out.println("drawing circle...");}  
9. }  
10. class Triangle extends Shape{  
11. void draw(){System.out.println("drawing triangle...");}  
12. }  
13. class TestPolymorphism2{  
14. public static void main(String args[]){  
15. Shape s;  
16. s=new Rectangle();  
17. s.draw();  
18. s=new Circle();  
19. s.draw();  
20. s=new Triangle();  
21. s.draw();  
22. }  
23. }  

Test it Now

Output:

drawing rectangle...

drawing circle...

drawing triangle...

ADAD

1. class Animal{  
2. void eat(){System.out.println("eating...");}  
3. }  
4. class Dog extends Animal{  
5. void eat(){System.out.println("eating bread...");}  
6. }  
7. class Cat extends Animal{  
8. void eat(){System.out.println("eating rat...");}  
9. }  
10. class Lion extends Animal{  
11. void eat(){System.out.println("eating meat...");}  
12. }  
13. class TestPolymorphism3{  
14. public static void main(String[] args){  
15. Animal a;  
16. a=new Dog();  
17. a.eat();  
18. a=new Cat();  
19. a.eat();  
20. a=new Lion();  
21. a.eat();  
22. }}  

Test it Now

Output:

ADAD

eating bread...

eating rat...

eating meat...

A method is overridden, not the data members, so runtime polymorphism can't be achieved by data members.

In the example given below, both the classes have a data member speedlimit. We are accessing the data member by the reference variable of Parent class which refers to the subclass object. Since we are accessing the data member which is not overridden, hence it will access the data member of the Parent class always.

1. class Bike{  
2. int speedlimit=90;  
3. }  
4. class Honda3 extends Bike{  
5. int speedlimit=150;  
6. public static void main(String args[]){  
7.   Bike obj=new Honda3();  
8.   System.out.println(obj.speedlimit);//90 
9. }  

Test it Now

Output:

90

Let's see the simple example of Runtime Polymorphism with multilevel inheritance.

1. class Animal{  
2. void eat(){System.out.println("eating");}  
3. }  
4. class Dog extends Animal{  
5. void eat(){System.out.println("eating fruits");}  
6. }  
7. class BabyDog extends Dog{  
8. void eat(){System.out.println("drinking milk");}  
9. public static void main(String args[]){  
10. Animal a1,a2,a3;  
11. a1=new Animal();  
12. a2=new Dog();  
13. a3=new BabyDog();  
14. a1.eat();  
15. a2.eat();  
16. a3.eat();  
17. }  
18. }  

Test it Now

Output:

ADAD

eating

eating fruits

drinking Milk

1. class Animal{  
2. void eat(){System.out.println("animal is eating...");}  
3. }  
4. class Dog extends Animal{  
5. void eat(){System.out.println("dog is eating...");}  
6. }  
7. class BabyDog1 extends Dog{  
8. public static void main(String args[]){  
9. Animal a=new BabyDog1();  
10. a.eat();  
11. }}  

Test it Now

Output:

Dog is eating

Since, BabyDog is not overriding the eat() method, so eat() method of Dog class is invoked.  

============================================================================== 

Connecting a method call to the method body is known as binding.

There are two types of binding

1. Static Binding (also known as Early Binding).
2. Dynamic Binding (also known as Late Binding).

Let's understand the type of instance.

Each variable has a type, it may be primitive and non-primitive.

1. int data=30;  

Here data variable is a type of int.

1. class Dog{  
2. public static void main(String args[]){  
3.   Dog d1;//Here d1 is a type of Dog 
4.  }  
5. }  

An object is an instance of particular java class,but it is also an instance of its superclass.

1. class Animal{}  
2. class Dog extends Animal{  
3. public static void main(String args[]){  
4.   Dog d1=new Dog();  
5.  }  
6. }  

Here d1 is an instance of Dog class, but it is also an instance of Animal.

When type of the object is determined at compiled time(by the compiler), it is known as static binding.

If there is any private, final or static method in a class, there is static binding.

1. class Dog{  
2. private void eat(){System.out.println("dog is eating...");}  
3. public static void main(String args[]){  
4.   Dog d1=new Dog();  
5.   d1.eat();  
6.  }  
7. }  

When type of the object is determined at run-time, it is known as dynamic binding.

1. class Animal{  
2. void eat(){System.out.println("animal is eating...");}  
3. }  
4. class Dog extends Animal{  
5. void eat(){System.out.println("dog is eating...");}  
6. public static void main(String args[]){  
7.   Animal a=new Dog();  
8.   a.eat();  
9.  }  
10. }  

Test it Now

Output:dog is eating...

In the above example object type cannot be determined by the compiler, because the instance of Dog is also an instance of Animal.So compiler doesn't know its type, only its base type. 

============================================================================== 

1. java instanceof
2. Example of instanceof operator
3. Applying the instanceof operator with a variable the have null value
4. Downcasting with instanceof operator
5. Downcasting without instanceof operator

The java instanceof operator is used to test whether the object is an instance of the specified type (class or subclass or interface).

The instanceof in java is also known as type comparison operator because it compares the instance with type. It returns either true or false. If we apply the instanceof operator with any variable that has null value, it returns false.

Let's see the simple example of instance operator where it tests the current class.

1. class Simple1{  
2. public static void main(String args[]){  
3.  Simple1 s=new Simple1();  
4.  System.out.println(s instanceof Simple1);//true 
5.  }  
6. }  

Test it Now

Output:true

An object of subclass type is also a type of parent class. For example, if Dog extends Animal then object of Dog can be referred by either Dog or Animal class.

1. class Animal{}  
2. class Dog1 extends Animal{//Dog inherits Animal 
3. public static void main(String args[]){  
4.  Dog1 d=new Dog1();  
5.  System.out.println(d instanceof Animal);//true 
6.  }  
7. }  

Test it Now

Output:true

If we apply instanceof operator with a variable that have null value, it returns false. Let's see the example given below where we apply instanceof operator with the variable that have null value.

1. class Dog2{  
2. public static void main(String args[]){  
3.   Dog2 d=null;  
4.   System.out.println(d instanceof Dog2);//false 
5.  }  
6. }  

Test it Now

Output:false

When Subclass type refers to the object of Parent class, it is known as downcasting. If we perform it directly, compiler gives Compilation error. If you perform it by typecasting, ClassCastException is thrown at runtime. But if we use instanceof operator, downcasting is possible.

1. Dog d=new Animal();//Compilation error 

If we perform downcasting by typecasting, ClassCastException is thrown at runtime.

1. Dog d=(Dog)new Animal();  
2. //Compiles successfully but ClassCastException is thrown at runtime 

Let's see the example, where downcasting is possible by instanceof operator.

1. class Animal { }  
2. class Dog3 extends Animal {  
3. static void method(Animal a) {  
4. if(a instanceof Dog3){  
5.        Dog3 d=(Dog3)a;//downcasting 
6.        System.out.println("ok downcasting performed");  
7.     }  
8.   }  
9. public static void main (String [] args) {  
10.     Animal a=new Dog3();  
11.     Dog3.method(a);  
12.   }  
13.  }  

Test it Now

Output:ok downcasting performed

Downcasting can also be performed without the use of instanceof operator as displayed in the following example:

1. class Animal { }  
2. class Dog4 extends Animal {  
3. static void method(Animal a) {  
4.        Dog4 d=(Dog4)a;//downcasting 
5.        System.out.println("ok downcasting performed");  
6.   }  
7. public static void main (String [] args) {  
8.     Animal a=new Dog4();  
9.     Dog4.method(a);  
10.   }  
11. }  

Test it Now

Output:ok downcasting performed

Let's take closer look at this, actual object that is referred by a, is an object of Dog class. So if we downcast it, it is fine. But what will happen if we write:

1. Animal a=new Animal();  
2. Dog.method(a);  
3. //Now ClassCastException but not in case of instanceof operator 

Let's see the real use of instanceof keyword by the example given below.

1. interface Printable{}  
2. class A implements Printable{  
3. public void a(){System.out.println("a method");}  
4. }  
5. class B implements Printable{  
6. public void b(){System.out.println("b method");}  
7. }  
8. class Call{  
9. void invoke(Printable p){//upcasting 
10. if(p instanceof A){  
11. A a=(A)p;//Downcasting  
12. a.a();  
13. }  
14. if(p instanceof B){  
15. B b=(B)p;//Downcasting  
16. b.b();  
17. }  
18. }  
19. }//end of Call class 
20. class Test4{  
21. public static void main(String args[]){  
22. Printable p=new B();  
23. Call c=new Call();  
24. c.invoke(p);  
25. }  
26. }  

Test it Now

Output: b method