Why can I cast an object? Can it be done with other objects?

Question

So I was writing a paintComponent(Graphics g) method and I realized at the beginning that I am casting it to Graphics2D g2 = (Graphics2D) g;. I wrote this code a while ago and just realized I have no clue what this is. I googled a bit but object casting is a bit foreign to me.

One object reference can be typecast into another object reference. This is called casting object.

^^Word for word from my textbook by Y. Daniel Liang

I don't understand why this works. Graphics and Graphics2D are two different objects how could they inherit instance variables and methods from each-other? Obviously I am aware of primitive casting ie widening and narrowing. That makes sense since they are just wrapper classes of Integer, Double, Byte etc...

The same object can be both a `Graphics` and a `Graphics2D`. The key point is that class `Graphics2D` **extends** the class `Graphics`. That cast only works because the object was a subtype of `Graphics2D` all along. — Tom Hawtin - tackline, Feb 13 '20 at 08:23
No they are not completly different, Graphics2D extends Graphics! So Graphics2D will have every exposed method of Graphics, in case the method does not recive a Graphics2D object it should throw an error though. https://stackoverflow.com/questions/4862960/explicit-casting-from-super-class-to-subclass — Nordiii, Feb 13 '20 at 08:24

score 2 · Accepted Answer · answered Feb 13 '20 at 09:16

With casting no object conversion or transformation of any kind is happening. Just imagine you have the following class structure:

class Mammal { }
class Human extends Mammal { }
class Dog extends Mammal { }

Now when you create a new instance of Human with Human human = new Human(); that will also be a Mammal, right? So you could write a method like:

public void doSoemthing(Mammal mammal) {
    if (mammal instanceof Human) {
        Human human = (Human) mammal;
        human.doWork();
    } else if (mammal instanceof Dog) {
        Dog dog = (Dog) mammal;
        dog.bark();
    }
}

and invoke the method like:

doSomething(new Human());

So your method can take any type of Mammal as an input parameter and in your method you can check what kind of Mammal it really is. So when you pass a new Human() as the input, the object's actual type will be Human. The reason because you can pass a Human to a method expecting a Mammal is because inheritance. So what your method will know is that the input parameter is definitely a Mammal. But it can be any kind of Mammal. If you want to know what the Object's actual type is you can use instanceof for example. And in this line:

Human human = (Human) mammal;

doesn't mean you are converting the mammal input parameter. It just means that from now on you want to use the input parameter as a Human. And you can do that, because with the isntanceof you check that it's really a Human. You could also do something like this:

public void doExample2(Object input) {
    if (input instanceof Integer) {
        System.out.println("I am a number");
    } else if (input instanceof Graphics) {
        System.out.println("I am a Graphics");
    }
}

Notice the type of teh input parameter. Object is the base class of everything.

So getting back to your scenario. You do that casting, because from the context of your application the input parameter will always be a Graphics2D, and that's why you can do that casting, and also to use the methods provided by Graphics2D.

I can't remember the correct term for this right now, but if you check using instanceOf and then cast, lets say you are overriding a method in a derived class that is in the base class. Which method will run and why if its not actually a conversion? Just from a logical perspective I would expect it to run the base class method and not the derived class method. — ErlichBachman, Feb 13 '20 at 09:41
The method of the actual runtime instance will be invoked. Here are a couple of examples: https://pastebin.com/X6DZHKpY But you can access the base class' overridden method, but only from the method which is overriding it, and from nowhere else. Extension of the above example: https://pastebin.com/b5uj4nYX (see the printWhoAmI method in ChildClass) And here is another example: https://pastebin.com/LnwLgUxG Here from GrandChildClass with super you can access ChildClass' printWhoAmI method, but not BaseClass' printWhoAmI. From GrandCC you'll never be able to access the overridden method from BC. — dfritsi, Feb 13 '20 at 10:43

score 1 · Answer 2 · answered Feb 13 '20 at 09:13

Both Graphics2D and Graphics are abstract classes, which means you can't have an instance of them, but you can have an object which extends one of them.

Graphics2D extends Graphics, so every object that extends Graphics2D will extend Graphics as well, but it doesn't mean every object that extends Graphics can be cast to Graphics2D.

abstract class Graphics {}

abstract class Graphics2D extends Graphics {}

class ClassGraphics extends Graphics {}

class ClassGraphics2D extends Graphics2D {}

class Main {

    public static void main(String[] args) {
        Graphics g1 = new ClassDebugGraphics();
        Graphics g2 = new ClassDebugGraphics2D();
        paintComponent(g1);
        paintComponent(g2);
    }

    public static void paintComponent(Graphics g) {
        Graphics2D g2 = (Graphics2D) g;
        System.out.print("Successful casting");
    }
}

In the above example both g1 and g2 are Graphics, but only g2 is Graphics2D.

paintComponent(g1); will throw java.lang.ClassCastException: ClassDebugGraphics cannot be cast to Graphics2D, while paintComponent(g2); will print Successful casting.

You didn't mention what is sent to paintComponent() in your code, but it extends Graphics2D so you can cast it to it.

My code is `paintComponent(Graphics g)`, I don't send it anything, it is called when the JFrame is created with `super.paintComponent(g);` inside my overridden paintComponent. So its not sent a Graphics2D but instead a Graphics object...sorry for any confusion that may have caused — ErlichBachman, Feb 13 '20 at 09:23
@ErlichBachman `Graphics` is the super class, `paintComponent` receive this type as a parameter, so you can send it anything that extends `Graphics` or extends something that extends something that extends `Graphics`, but it will still be the type of the original object. — Guy, Feb 13 '20 at 09:27

score 0 · Answer 3 · answered Feb 13 '20 at 09:06

0

If you look here "https://docs.oracle.com/javase/7/docs/api/java/awt/Graphics2D.html"

In the top you will see java.lang.Object -> java.awt.Graphics -> java.awt.Graphics2D

So what does it mean!?: java.lang.Object is the super class for booth Graphics and Graphics2D. Graphics is super class for Graphics2D. So Graphics2D extends Graphics, therefore they are not so "different" objects.

answered Feb 13 '20 at 09:06

A.Bras

21
4

This does not explain how the compiler is actually interpreting the cast. Like I said I OBVIOUSLY understand primitive casting. So casting from Graphics to Graphics2D makes sense. – ErlichBachman Feb 13 '20 at 09:09
As the casting didn't throw exception this means that the "g" was instance of Graphics2d at this moment, otherwise the casting would fail – A.Bras Feb 13 '20 at 09:26

score 0 · Answer 4 · answered Feb 13 '20 at 09:19

If you have a look at the Javadoc, you see, that java.awt.Graphics2D is a subclass of java.awt.Graphics. https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/java/awt/Graphics2D.html

In Java 11 the direct known subclasses of Graphics are DebugGraphics and Graphics2D, so when you have a Graphics g, it is most probably also a Graphics2D, since Graphics itself is an abstract class and thus, cannot be instantiated directly. So you can cast the object to the specific type. To be sure, you could do check first, like so.

if (g instanceof Graphics2D) {
    Graphics2D g2 = (Graphics2D) g;
    ...
}

The cast is probably done, in order for you to be able to access methods, defined in Graphics2D, but not in Graphics.

Another look at the Javadoc will reveals, that Graphics2D also is an abstract class. So, what you can do, to see, what class you are really dealing with is, print out the class name like this:

System.out.println(g.getClass().getName());

Why can I cast an object? Can it be done with other objects?

4 Answers4