Question

I have a question and below is my code.

class A
{
    int i=10;
    public void m1() {
        System.out.println("I am in class A");
    }    
}

class B extends  A 
{    
    public void m1() { 
        System.out.println("I am in class B"); 
    }       
}

class main2 extends A 
{       
    public static void main(String...a) {
        A a1= new B();
        a1.m1();    
    }
}

Now my question; it’s OK to get the variable “i” of the parent class A, but the method that I am getting is also of class A. Is it getting class B’s method, as it overrides class A’s method?

Answer 1

In Java, any derived class object can be assigned to a base class variable. For instance, if you have a class named A from which you derived the class B, you can do this:

A a1 = new B();

The variable on the left is type A, but the object on the right is type B. As long as the variable on the left is a base class of B, you are allowed to do that. Being able to do assignments like that sets up what is called “polymorphic behavior”: if the B class has a method that is the same as a method in the A class, then the version of the method in the B class will be called. For instance, if both classes define a method called m1(), and you do this:

a1.m1();

the version of m1() in the B class will be called. Even though you are using an A variable type to call the method m1(), the version of m1() in the A class won’t be executed. Instead, it is the version of m1() in the B class that will be executed. The type of the object that is assigned to the A variable determines the method that is called.

So, when the compiler scans the program and sees a statement like this:

a1.m1();

it knows that a1 is of type A, but the compiler also knows that a1 can be a reference to any class derived from A. Therefore, the compiler doesn’t know what version of m1() that statement is calling. It’s not until the assignment:

A a1 = new B();

is executed that the version of m1() is determined. Since the assignment doesn’t occur until runtime, it’s not until runtime that the correct version of m1() is known. That is known as “dynamic binding” or “late binding”: it’s not until your program performs some operation at runtime that the correct version of a method can be determined. In Java, most uses of inheritance involve dynamic binding.