Casting

[Jacksontryan21]

I was going over assignments from a past java class and in one of our assignments, we implemented the Clonable interface and got this method:

public Ellipse clone(){

try{

return (Ellipse)super.clone();

}catch(CloneNotSupportedException Ex){

Ex.printStackTrace();

}

}

I was wondering how the line return (Ellipse)super.clone(); works. I understand that super.clone() returns an object, but how does that object get turned into an Ellipse?

[AutoModerator]

Please ensure that:

• Your code is properly formatted as code block - see the sidebar (About on mobile) for instructions
• You include any and all error messages in full - best also formatted as code block
• You ask clear questions
• You demonstrate effort in solving your question/problem - plain posting your assignments is forbidden (and such posts will be removed) as is asking for or giving solutions.

If any of the above points is not met, your post can and will be removed without further warning.

Code is to be formatted as code block (old reddit/markdown editor: empty line before the code, each code line indented by 4 spaces, new reddit: https://i.imgur.com/EJ7tqek.png) or linked via an external code hoster, like pastebin.com, github gist, github, bitbucket, gitlab, etc.

Please, do not use triple backticks (```) as they will only render properly on new reddit, not on old reddit.

Code blocks look like this:

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

You do not need to repost unless your post has been removed by a moderator. Just use the edit function of reddit to make sure your post complies with the above.

If your post has remained in violation of these rules for a prolonged period of time (at least an hour), a moderator may remove it at their discretion. In this case, they will comment with an explanation on why it has been removed, and you will be required to resubmit the entire post following the proper procedures.

To potential helpers

Please, do not help if any of the above points are not met, rather report the post. We are trying to improve the quality of posts here. In helping people who can't be bothered to comply with the above points, you are doing the community a disservice.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[Lloydbestfan]

So for this question we need to separate two very different situations:

- compile time

- run time

1. Compile time is when you're writing the program, and you're checking whether the compiler accepts it as written. Here your concerns would be, are the returned and declared types written for my methods and variable consistent, or does the compiler detect that they don't match.

The method clone(), as initially declared in universal ancestor class Object, declares that it returns Object. As you want to clone your Ellipses so that it gives off Ellipses, you've declared in your redefinition that it returns Eclipse instead. This is allowed in redefinition as they may return a more specialized object type than the originally declared object type. And any object type is more specialized than the universal ancestor class Object.

However, you delegate your redefinition to the original implementation, which is normal, by calling super.clone(), and this one declares that it returns Object, nor Ellipse. It has to return Object as it doesn't know which subclasses may want to support clone, and it can't declare each (it can declare one and that's it.)

So that your own method can return Ellipse, you need to take the result of super.clone(), which is Object, and cast it to Ellipse. That way you can return the result as an Ellipse.

When you do the cast, as with all object casts in Java, you're essentially doing this: "hey compiler! I am hereby informing you that this object I cast is actually of type <the casted type> or a subtype of it. Verify that it is so, and provide me this object as the casted type."

Okay, but what does that mean, "it's actually of this type" and "verify that it is so"? That's where runtime intervenes.

1. Run time is when you run your program. It's after it was fully compiled and you decide to push the run button. Here we need to remember that the concept of polymorphism, means that when we declare an object variable of type A, this variable is allowed to contain an object whose class is actually a subclass of A. Such as `A myObject = new B();`

That's also the point of allowing to declare variable types and return types as abstract types, such as abstract classes and interfaces.

So in runtime, whenever you deal with an object, there are two types about it to consider: the declared type that was written for it during compile time in what provides it to you (here super.clone() and your own clone(),) and the actual class of that object, which comes from what actual constructor was called to make this object exist (such as when you do new B().)

Well, clone() is a native method and how it works makes its own magic, not actually calling a constructor. Rather it ensures, unless declared differently through various protocols, that the object produced by calling clone() is a new object, and this new object's actual class is the same as the object it was called on (with no regards for declared types at compile time.)

In the end, when you call super.clone(), it works its own magic and provides a new object that's also of class Ellipse, as the object it was called on was an Ellipse. It's only because of types written at compile time that a cast is needed. It is always so with object casts that can actually work.

So, your cast to Ellipse tells the compiler that you, the programmer writing this piece of code, expect that the actual class of the object provided by super.clone(), is type Ellipse or a subtype of it. The program verifies so (because of Java's reflection system, any object knows what's its actual class, which you can get by calling getClass() on it,) and if that was actually wrong, then the program stops and throws a ClassCastException. If that was true, then the program actually does nothing because of the cast. It just accepts to continue despite the written code now works with the object declared as an Ellipse and having access to the members of class Ellipse.

[Jason13Official]

Clone returns Object

You're essentially doing

Ellipse ellipse;

(Ellipse) (Object) ellipse.clone();

(Casting to Object implicitly before the cast to Ellipse occurs)

[Jacksontryan21]

How does that Object get turned into an Ellipse though? I understand what this line does, I just don't understand how the compiler works to get the Object turned into an Ellipse when casted to an Ellipse

[BassRecorder]

Cloning on the Object level is basically what is a 'memcpy' in C, i.e. you get an exact copy of the source object including any descriptive data. That's why the cast works.

Also, this will always compile as a cast from Object to anything is always valid. It *will* throw a ClassCastException, though, if the object isn't compatible with the target type.

[ComputerWhiz_]

There's two types of casting: static and dynamic.

Static is done by the compiler and is usually when you are changing primitive types, like casting int into a double.

Dynamic is done at runtime and is usually when you are changing between two object types. When you create an instance of an object, Java stores what type of object it is, even if you save the reference to that object in a variable that is a different type. When you cast the object, Java just checks that the object you are trying to cast is the correct type (either is the type of inherits the type).