0

I am having difficulty in understanding how an instance variable gets initialized when we declare it. Consider the following snippet:

class Rat {
    private int val = 20;
}

class Cat {
    private Rat rat = new Rat();
}

I am not able to understand how we initialize the instance variables at the time of their declaration within class; aren't these variables supposed to get their "values" or "references" when we actually create an object, for example in main we do:

main() {

    Cat cat = new Cat();
}

So that each object have their "own" set of instance variables; and for example to initialize Rat instance variable of Cat, we should do:

 cat.Rat = new Rat();

Can anyone help me understand this.

CuriousMind
  • 8,301
  • 22
  • 65
  • 134
  • understand what? the instance variables are only accessible by instances, and instances only exist after running the constructor. What exactly is your question? – Stultuske Feb 22 '18 at 09:22
  • 1
    The `rat` field in `Cat` isn't initialized "at the time of declaration". It is initialized when `Cat` is instantiated (by executing `new Cat()`). Part of instantiating the `Cat` class is initializing the fields. – khelwood Feb 22 '18 at 09:23
  • I come from C++ back ground and things work a bit different there; I haven't seen such kind of declaration in C++ and same is valid in Java. It is in that perspective I was trying to understand how it works in Java. – CuriousMind Feb 22 '18 at 09:25
  • 1
    @CuriousMind Afaik since C++11 you can also initialize member variables in exactly the same way in C++: https://stackoverflow.com/questions/13662441/c11-allows-in-class-initialization-of-non-static-and-non-const-members-what-c – OH GOD SPIDERS Feb 22 '18 at 09:31
  • @OHGODSPIDERS: Thanks for pointing me to this post; however in my usage and the kind of code I have seen, traditionally C++ compilers flagged error if we declare and initialize non-static variables within a class. It seems that specification of C++ have changes, kind of them learnt Java way. I thank you for sharing this posts here. – CuriousMind Feb 22 '18 at 09:34

4 Answers4

4

I am not able to understand how we initialize the instance variables at the time of their declaration within class

The instance variables are initialized when an instance is created. Each time you create an instance of Cat, private Rat rat = new Rat(); is executed. Each time you create an instance of Rat, private int val = 20; is executed (right after the execution of the super-class constructor and before the execution of the current class's constructor body).

When

Cat cat = new Cat();

is executed, right before the Cat constructor's body is executed, the instance variables of Cat are initialized, so

private Rat rat = new Rat();

is executed. Now, right before the Rat constructor's body is executed, the instance variables of Rat are initialized, so

private int val = 20;

is executed.

Eran
  • 387,369
  • 54
  • 702
  • 768
1

As per definition in https://docs.oracle.com/javase/specs/jls/se8/html/jls-12.html#jls-12.5 of the JVM the fields are initialized in step 4 of the creation of a new instance of the class. So before the body of your constructor is executed.

  1. Assign the arguments for the constructor to newly created parameter variables for this constructor invocation.

  2. If this constructor begins with an explicit constructor invocation (§8.8.7.1) of another constructor in the same class (using this), then evaluate the arguments and process that constructor invocation recursively using these same five steps. If that constructor invocation completes abruptly, then this procedure completes abruptly for the same reason; otherwise, continue with step 5.

  3. This constructor does not begin with an explicit constructor invocation of another constructor in the same class (using this). If this constructor is for a class other than Object, then this constructor will begin with an explicit or implicit invocation of a superclass constructor (using super). Evaluate the arguments and process that superclass constructor invocation recursively using these same five steps. If that constructor invocation completes abruptly, then this procedure completes abruptly for the same reason. Otherwise, continue with step 4.

  4. Execute the instance initializers and instance variable initializers for this class, assigning the values of instance variable initializers to the corresponding instance variables, in the left-to-right order in which they appear textually in the source code for the class. If execution of any of these initializers results in an exception, then no further initializers are processed and this procedure completes abruptly with that same exception. Otherwise, continue with step 5.

  5. Execute the rest of the body of this constructor. If that execution completes abruptly, then this procedure completes abruptly for the same reason. Otherwise, this procedure completes normally.

Ben
  • 1,665
  • 1
  • 11
  • 22
1

From the below code snippet,

main() {

    Cat cat = new Cat();
}

It is evident that, we are trying to create an Object 'Cat'. So, when we call this, the Cat Class would be loaded(if it is not already loaded). While the Class is being loaded, it will initialize the instance variables.

In the below scenario, 

   class Cat {
    private Rat rat = new Rat();
}

As the Cat class has an instance variable which is dependent on another class called Rat, Rat class would be loaded and during the process, instance variable in Rat would be initialized.

class Rat {
    private int val = 20;
}

So, the above code snippet would be initialized first, then this assignment would be done private Rat rat = new Rat(); and finally the Cat object( Cat cat = new Cat(); ) would be created and assigned it to the cat reference variable.

Jayanth
  • 746
  • 6
  • 17
0
class Rat {
    private int val = 20;
}

Until you create instance of Rat, the variable val doesn't hold value '20'. So, In order for JVM to assign value 20 to val, you need to create Rat instance with 'new' operator.

Similarly,
class Cat {
    private Rat rat = new Rat();
}

Unless you create instance of Cat using 'new' operator, variable rat will not get initialized with 'new Rat()' instance.

Similarly for Cat instance and initialization

Finally, static variable's get initialized at the time of class loading and available till the class loader is live And instance variables are initialized at the time of Class's instantiation and based on its scope i.e global variable or Local Variable.

Please read about the scope to know more about it.

student23
  • 40
  • 5
Ravi Surthi
  • 41
  • 2