Casting in Java - what does (Parent) this mean?

Question

class A {
    public int a = 100;
} 

class B extends A {
    public int a = 80;
} 

class C extends B {
    public int a = 10;

    public void show() {
        int a = 0;

        System.out.println(a);
        System.out.println(super.a);
        System.out.println(((A) this).a);
    }
}

What does ((A) this).a in the line System.out.println(((A) this).a); do? Is it upcasting/downcasting thisor is something else happening here?

I also tried System.out.println(this); and System.out.println((A)this); and they both have the same output. What exactly is happening here?

`System.out.println(this);` and `System.out.println((A)this);` effectively calls `toString` of the object instance. Methods override each other therefore the output will always be the same. — Robert, Oct 01 '20 at 11:54
@Robert ok, but `println` doesn't have either `this` or `(A)this` as an argument in those examples. — Federico klez Culloca, Oct 01 '20 at 11:56
`(A) this` simply casts `this` to `A`. So `((A) this).a` will first cast `this` to `A`, and then look for `a` as defined in class `A`. It should print 100. — S.L. Barth is on codidact.com, Oct 01 '20 at 11:58
Field "overriding" (there is real field overriding is it more hiding) works totally different than method overriding: https://stackoverflow.com/questions/9414990/if-you-overwrite-a-field-in-a-subclass-of-a-class-the-subclass-has-two-fields-w — Robert, Oct 01 '20 at 11:58
"*I also tried System.out.println(this); and System.out.println((A)this); ...*" Methods have dynamic dispatch. Fields do not — Michael, Oct 01 '20 at 12:00

score 2 · Accepted Answer · answered Oct 01 '20 at 12:14

In the java programming language, we have classes. When we write java code, we create instances of those classes, for example:

Object o = new Object();

Object is a class. Writing new Object() creates an instance of that class. The above code declares a variable o and assigns it [a reference to] an instance of class Object.

In the terminology of the java programming language, we say that variable o has type Object.

In the code in your question, a variable that is assigned an instance of class C, really has three types.

It has type C.
It has type B since B is the superclass of C.
It has type A because it indirectly extends class A also.

In the context of the code in your question, this is a special variable whose type is C. Writing (A) this is telling java to relate to the variable this as if its type is A.

Class A cannot access its subclasses. Hence it is only aware of its class member a. Hence when you write this line of code...

((A) this).a

You are accessing the member of class A only.

0009laH · Answer 2 · 2020-10-01T12:05:14.283

1

System.out.println(a);
a is the one from the show method of your C class → a = 0
System.out.println(super.a);
a is the one from the super-class of C, which is B → a = 80
System.out.println(((A) this).a);
First, you cast your C instance (this) into A, then you call a which is a member of the A class → a = 100

edited Oct 01 '20 at 12:05

answered Oct 01 '20 at 11:58

0009laH

1,960
13
27

score 1 · Answer 3 · answered Oct 01 '20 at 12:09

There is also something to consider : method will always take the more specialized one (except if super is used), where field will be taken directly from the type referenced (even if there is an extending class).

For example, if I add getA() in each classes :

class A {
    public int a = 100;

    public int getA(){
        return a;
    }
}

class B extends A {
    public int a = 80;

    public int getA(){
        return a;
    }
}

class C extends B {
    public int a = 10;


    public int getA(){
        return a;
    }
    public void show() {
        int a = 0;

        System.out.println(a);
        System.out.println(super.a);
        System.out.println(((A) this).a);
        System.out.println(getA());
        System.out.println(super.getA());
        System.out.println(((A) this).getA());
    }
}


class Scratch {

    public static void main(String[] args) {
        new C().show();
    }
}

I get the following output :

Which means that in the case of the method, except in the case of super.getA() which explicitly goes to the superclass, casting your C into a A doesn't change much for methods, as it impacts the field.

score 1 · Answer 4 · answered Oct 01 '20 at 14:12

If you write something like obj.a, obj.getA() or someMethod(obj), Java somehow has to find the actual field or method to be used, based on the type or class of obj. There are two distinct dispatch mechanisms involved (plus the special construct super).

Dynamic dispatch (polymorphism, overriding): This is used when calling an instance method on the object, as in obj.getA(). Then the runtime class of the obj is examined, and if this class contains a getA() method, this is used. Otherwise, the direct parent class is examined for a getA() method, and so on up to the Object class.
Static dispatch: In cases like obj.a or someMethod(obj), the runtime class of obj doesn't matter. Involved is only the compiler, and from his knowledge of obj's type, he decides which field or method to use.
super dispatch: If you write super.getA() or super.a, your getA() method or a field is ignored, and instead the next-higher class in the hierarchy is used that contains such a method or field.

In your case you have 3 fields plus one local variable, all with the same name a. (By the way, it's a very bad idea to have such name conflicts in professional code.) We are inside a method show() declared in the C class. Let's have a look at some different expressions and what they mean here:

a references the local variable a. There's no dispatch needed, it's just that local definitions take precedence over fields.
this.a is a static-dispatch expression, so it's important what the compiler thinks about the type of this. And that's always the class where this code has been written. In your case, it's class C, so the field a from class C is used, the one being 10.
super.a is a super-dispatch expression, meaning that the a field from this class C is ignored and the next higher one taken (the one from B, in our case).
((A) this).a is static dispatch, but the (A) casting has a significant effect. The expression before the dot originally comes from this, being of type C, but the (A) cast tells the compiler to believe it were of type A. This is okay, as every C also is an A, by inheritance. But now, static dispatch sees something of type A in front of the dot, and dispatches to the a field from the A class, and no longer from C.
getA(), this.getA() and ((A) this).getA() are all dynamic-dispatch examples, all giving the same result. The method called will be the one based on the runtime class of this object. This will typically be one defined in the C class. But if show() was called on an object of a subclass of C, e.g. D, and D had its own getA() method, that one would be used.
super.getA() is a case of super-dispatch, it will call the getA() method next higher up in the class hierarchy from the current class, e.g. B.

score 0 · Answer 5 · edited Oct 01 '20 at 14:20

0

System.out.println(this);

And

System.out.println((A)this)

These two prints the object reference to class C with toString() method.

System.out.println(((A)this).a);

This is upcasting, child object to parent object.

edited Oct 01 '20 at 14:20

NearHuscarl

66,950
18
261
230

answered Oct 01 '20 at 12:42

sakthi

16
2

Casting in Java - what does (Parent) this mean?

5 Answers5