hey can you tell me how does the output comes in the following code?

I am a bit confused about how this code works can you help. I am trying to understand it in deep. So please feel free to refer any links for depth understanding about the subject matter.The output is A B B A

    public class RuntimePolymorphism {
        public static void main(String[] args) {
            A a = new B();
            B b = new B();

            System.out.println(a.c + " " + a.getValue()
                + " " + b.getValue() + " " + b.getSuperValue());
        }
    }
      
    class A {
        char c = 'A';

        char getValue() {
            return c;
        }
    }
      
    class B extends A {
        char c = 'B';

        char getValue() {
            return c;
        }

        char getSuperValue() {
            return super.c;
        }
    }

Actually, it's an interesting question ;), by the code, from the fist sight, I would say, it should output A A B A, yet it producing A B B A.

Then, I found a possible typo (or it was intentional, don't know):

A a = new B();
B b = new B();

we have two B's here, but we are also doing a type casting at the moment of instantiation of a variable. Even if we make c field as public it still produces the same result.

But, on the other hand, if we'll update to code like this:

A a = new A();
B b = new B();

everything will be as expected: A A B A.

Interesting finding: if we remove overloaded getValue() from the B class, the output will be<br> A A A A...

Final conclusion: we can inherit a non-private field (that's we can access it from derived class), but we can't "overload" it the way we do with methods.

Thus, in Java, polymorphism is only working with methods and not with the fields.

The instance variable C from A is simply hidden in B<br>
– A.C is ‘A’ because it's set in the class A<br>
– A.getValue() returns ‘B’ because the object is of type B

So I think we should first understand the difference between Hiding and Polymorphism.

When you declare a subclass with a variable name the same as the superclass variable, then the subclass variable just hides the superclass variable.

For Runtime Polymorphism, a subclass method would need to override a superclass method. When a method in a subclass has the signature ( name and parameters ) and same return type as a method in its superclass, then the method in the subclass overrides the method in the superclass.

Another important point is that Polymorphismm ( Runtime in this case ) acts on methods that are evaluated at run time. But the initialization of values to the variables happens at compile time.

1. So, when A a = new B(); is executed, a's instance variable c has the value 'A'. So even if the reference a is pointing to a B object, the instance variables it refers to would be that of A.

Hence the output when we run a.c would be A.

2. But since the method getValue() is overriden in the subclass, a would call the overriden method ( because it is pointing to the subclass B object ).

Hence the output when we run a.getValue() would be B

So, when B b = new B(); is executed, b's instance variable c has the value 'B'. And this hides the variable c of the superclass. And if we want to refer to the immediate superclass's instance variables then we access it via super.<variable_name> So even if the reference a is pointing to a B object, the instance variables it refers to would be that of A.

3. The reference b is pointing to an object of type B and hence it would call B's getValue() method.

Hence the output when we run b.getValue() would be B.

4. As discussed above, we access the immediate superclass's instance variables via super.<variable_name>

Hence the output when we run b.getSuperValue() would be A