什么时候为变量分配内存空间？

Question

Does the compiler allocate 4 bytes of memory when the variable is declared:

int a;

Or does it allocate memory when a value is assigned to it:

a = 5;

When is memory allocated? During variable declaration or initialization?

Answer 1

The variable is allocated when the structure containing it is allocated.

For a local variable in a method this is (with some caveats) when the method is invoked.

For a static variable this is when the class is "initialized" (which happens some time after it's loaded and before it's first used).

For an instance variable this is when the instance is created.

Answer 2

In most programming languages the compiler is allowed to choose when to allocate space for variables. The only thing you are guaranteed, is that the storage will be available if and when you need it.

A short anecdote...

The C programming language used to require that all variables used in a method be declared at the top of the method. This was because compilers used to reserve storage for all stack (local) variables in a method as soon as you entered the method. Today that requirement doesn't exist in part because compilers are a lot smarter.

Most compilers of C-like languages will defer allocation of instances until first use for optimized code. The REALLY tricky thing here is that the first use may not be where you think it is, and it may not occur at all. For example, if you have the following code:

int foo(int x) {
  int y = 5;
  if (x > 5)
    y += x;
  return y;
}

You might think the first use is when you assign 5 to y, but the compiler could optimize that code to something more like:

int foo(int x) {
  if (x > 5)
    return 5 + x;
  return 5;
}

In this code y never really exists at all.

TL;DR - The compiler actually isn't guaranteed to allocate memory on declaration or use. Trust the compiler, it is (usually) smarter than us all.

Answer 3

When we have “ declared '' a variable, we have meant that we have told the compiler about the variable; ie its type and its name, as well as allocated a memory cell for the variable (either locally or globally). This latter action of the compiler, allocation of storage, is more properly called the definition of the variable.

Simply Definition = Variable Declaration + Variable initialization

JVM divides memory into stack and heap memory. Whenever we declare new variables and objects, call new method, declare a String or perform similar operations, JVM designates memory to these operations from either Stack Memory or Heap Space.

• Local variables are created in the stack
• Instance variables are created in the heap & are part of the object they belong to.
• Reference variables are created in the stack.