10

Let's say I have this piece of code:

class Animal {
    int legs = 4;
    int head = 1;
}

public class Dog extends Animal {
    public static void main (String []args) {
        Dog dog = new Dog();
    }
}

I am aware of the super() implicitly placed in the first line of the no-args constructor, so I know that the Animal constructor will be executed and so the Animal's instance variable will be set.

To this purpose I would like to understand if, once those variables have been initialized by the super constructor (Animal), those instance variable will be kept there in the Animal object or copied to the subclass (Dog).

In the first case an object Animal will be instantiated implicitly by super(); and whenever the instance Dog will need to access one of those variable it will be done accessing to the variables kept in the instance Animal (created on background). Or second case, if the object Animal will be temporary created, all the instance variable (in Animal) copied to the Dog instance and then deleting the Animal's instance temporary created.

I personally think that for example a Dog object would be directly linked to an Animal object which is directly connected to an object.

Is it in this way?

Improve this question

4 Answers 4

Reset to default
16

There's only one object, which is immediately (right from the start) a Dog instance. It has all the fields of Dog (not that you have any here) and all the fields of Animal.

Initially all the variables will be set to their default values (0, null etc). Then when you get to each class's constructor body (after calling the superclass constructor), the instance variable initializers are executed, then the constructor body for that class is executed.

There's no copying required, as there's only ever one object. So for example, if you were to write an Animal constructor like this:

public Animal() {
    System.out.println(this.getClass());
}

... it would print out Dog, because the object is already a Dog, even though its Dog constructor won't have been executed yet.

Improve this answer
Sign up to request clarification or add additional context in comments.

11 Comments

@zvzdhk Because the object itself is a Dog. Even in the constructor (and also in the super constructor) this refers to the current object. So it may look strange, but it`s quite straightforward.
@GaborSch: I think zvzdhk might have been referring to the speed of response, rather than asking a technical question. I could be wrong, of course.
@GaborSch, no, answer is clear. I opened this question exactly as it had been published. And when I finished to read question, Jon already posted this answer...
@GaborSch: Practice, I guess. I'm a reasonably quick typist, and I have a fair amount of experience at explaining this sort of thing.
@Rollerball Actually one object is allocated, with all the properties of the super class and the sub class. It is a continuous memory area, the super members are at the beginning, the sub members are at the end of the memory area. Then those members are initialized (e.g. head=1), then the constructors are called. Remember, the should must call super() as the first call, so it starts with Object() then Animal() finally withDog().
|
8

Your Dog extends Animal, and the head, legs variables are not private, so you will access them from the Dog instance.

In practice, the following happens:

  • You create a Dog instance, which is also an Animal
  • all the object properties are created and initialized (including head, and after the properties of Animal as well)
  • The implicit constructor of Dog is called (it calls super())
  • The implicit constructor of Animal is called

And the result is an Object, which is a Dog, but implicitly also an Animal.

How a Dog object looks like (let's forget about the Object class for the sake of the example). Let's suppose Dog has a public String name; property as well.

Here is a memory map of a Dog instance:

Addr  Type     Name      Defined in:
------------------------
| 0 | int    | legs    | Animal
| 1 | int    | head    | Animal
| 2 | String | name    | Dog
------------------------
  • If you have an Animal, you access the head as a variable at address 1,
  • If you have a Dog, you access the name as a variable at address 2,
  • If you have an Dog, you access the head as a variable at address 1

The code that runs in the body of Animal class can see only addresses 0-1. The code that runs in the Dog class can access addresses 0-2. If a property would be private to the superclass, then that address would be forbidden for the subclass.

This memory map makes is possible to downcast the objects very easily: the same memory mapping is used, only the treatment (the code and the visibility) is different.

I hope it clarifies a bit.

Improve this answer

1 Comment

Updated with the explanation of the inherited object structure.
2

once those variables have been initialized by the super constructor (Animal), those instance variable will be kept there in the Animal object or copied to the subclass (Dog).

Firstly, Instance variables are not overriden in sub-class. they are only visible. They will not be copied in Dog's instance. You can access them from Dog class with Dog's instance if they are marked either public, protected or no-modifier

Improve this answer

2 Comments

So are linked together as I thought? How many objects created eventually?
@Rollerball as John skeet already answered it, there will only be one object created(Dog object) :)
1

There is no Animal Object , only a Dog object will be created . The Dog object has variables legs,head inherited from Animal object. They will act as if its the members of Dog object. Animal class constructor will be called since you are extending the Animal class in Dog.And since Animal implicitly extends Object , the Object class constructor will be called from Animal.

How Java handles these calls are internal to Java and may change from version to version but behavior you should expect to keep same.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.