Polymorphism

A variable of a supertype can refer to a subtype object.

Polymorphism in Java has two types:

Compile time polymorphism (static binding)
Runtime polymorphism (dynamic binding)

##Compile time polymorphism (static binding)

When type of the object is determined at compile time, It is Compile time polymorphism (static binding).

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

class DemoOverload{
    public int add(int x, int y){  //method 1
    return x+y;
    }

    public int add(int x, int y, int z){ //method 2
    return x+y+z;
    }

    public int add(double x, int y){ //method 3
    return (int)x+y;
    }

    public int add(int x, double y){ //method 4
    return x+(int)y;
    }
}

class Test{
    public static void main(String[] args){
    DemoOverload demo=new DemoOverload();
    System.out.println(demo.add(2,3));      //method 1 called
    System.out.println(demo.add(2,3,4));    //method 2 called
    System.out.println(demo.add(2,3.4));    //method 4 called
    System.out.println(demo.add(2.5,3));    //method 3 called
    }
}

Runtime polymorphism (dynamic binding)

When type of the object is determined at runtime, it is Runtime polymorphism (dynamic binding).

If we call the overridden method on the superclass reference then the subclass version of the method will be called.

public class PolymorphismDemo {
        
    public static void main(String[] args){
        m(new GraduateStudent());
        m(new Student());
        m(new Person());
        m(new Object());   
    }

    public static void m(Object x) {
        System.out.println(x.toString());
    }
}

class GraduateStudent extends Student {
  	//nothing here 
    /*
    GraduateStudent does not have a toString method
    Therefore when calling m(new GraduateStudent()),
    It gets the superclass's method in runtime.
    */
}

class Student extends Person {
    public String toString() {
        return "Student";
    }
}

class Person extends Object {
    public String toString() {
        return "Person";
    }
}

Output

Student
Student
Person 
java.lang.Object@293e75df

Which implementation is used will be determined dynamically by the Java Virtual Machine (JVM) at runtime.

This capability is known as dynamic binding.

Another example of Runtime polymorphism (dynamic binding)

class A {
    public void p() {
        System.out.print("A");
    }
}
class B extends A {
    public void p() {
        System.out.print("B");
    }
}

public class Test {
    public static void main(String args[]) {
       	A a = new B(); //Type is A but point to B
      	a.p(); //Invoke void p() of B (overrided)
      	B b = new B(); //Type is B, point to B
      	b.p(); //Invoke void p() of B
    }
}

//Output: BB

Note if the Methods are static, they will not get overrided.

class A {
    static void p() {
        System.out.print("A");
    }
}
class B extends A {
    static void p() {
        System.out.print("B");
    }
}

public class Test {
    public static void main(String args[]) {
       	A a = new B(); //Type is A but point to B
      	a.p(); //Invoke void p() of A because Static
      	B b = new B(); //Type is B, point to B
      	b.p(); //Invoke Static void p() of B
    }
}

//Output: AB

Recall: when calling static method, we can call the method without new an object.

class A {
    static void p() {
        System.out.print("A");
    }
}
class B extends A {
    static void p() {
        System.out.print("B");
    }
}

public class Test {
    public static void main(String args[]) {
       	A.p();
      	B.p();
    }
}

//Output: AB

Another Example:

class A {
    public A(int i) {
        System.out.println(myMethod(i));
        System.out.println("A1");
    }
    int myMethod(int i) {
        System.out.println("A2");
        return i;
    }
}

class B extends A {
    public B(int i, int j) {
        super(10);
        System.out.println("B1");
    }
    int myMethod(int i) {
        System.out.println("B2");
        return i;
    }
}

public class Test {
    public static void main(String args[]) {
       	B b = new B(1,2)
    }
}

//Output:
// B2
// 10
// A1
// B1

Member variables have static binding

In Java, member variables have static binding because Java does not allow for polymorphic behavior with member variables.

class A {
    int i = 10;
}
class B extends A {
    int i = 20;
}
class C extends B {
    int i = 30;
}

public class Test {
    public static void main(String args[]) {
        A a = new C();
        System.out.print(a.i + " ");
        C c = new C();
        System.out.print(c.i + " ");
        B b = new B();
        System.out.print(b.i);
    }
}

//Output: 10 30 20

Implicit Conversion

class Person{
    
    void p(double n){
        System.out.println("A");
        System.out.println(n);
    }
}

class Teacher extends Person{
    void p(int d){
        System.out.println("B");
        System.out.println(d);
    }

    void p(double n){
        System.out.println("B2");
        System.out.println(n);
    }
}

class Test{
    public static void main(String[] args){
        //Person aa = new Person();
        //Teacher aa = new Person(); //error: incompatible types: Person cannot be converted to Teacher
        Person aa = new Teacher();
        //Teacher aa = new Teacher();
        aa.p(44);
    }
}

Output is:

B2

44.0

Let’s see another example.

class A {
    void p(double n) {
        System.out.println("A");
        System.out.println(n);
    }
}
class B extends A {
    void p(int d) {
        System.out.println("B");
        System.out.println(d);
    }
    void p(String c) {
        System.out.println(c);
    }
}

public class Test {
    public static void main(String args[]) {
        A aa = new A();
        B bb = new B();
        aa.p(123.2);
        bb.p(456.7);
        aa = new B();
        bb = new B();
        aa.p("Cat1"); //Error incompatible types: String cannot be converted to double
        aa.p(44); // A 44.0
        bb.p("Cat2"); // Cat2
        bb.p(55); // B 55
    }

}

Inheritance vs Polymorphism

Inheritance is implemented on the classes
Polymorphism is implemented on methods/functions.

Accessibility Summary

Modifier on members in a class	Accessed from the same class	Accessed from the same package	Accessed from a subclass	Accessed from a different package
public	Yes	Yes	Yes	Yes
protected	Yes	Yes	Yes	No
default	Yes	Yes	No	No
private	Yes	No	No	No

A Subclass Cannot Weaken the Accessibility

A subclass may override a protected method in its superclass and change its visibility to public.
However, a subclass cannot weaken the accessibility of a method defined in the superclass.