Question

I am thinking about memory allocation in Java i.e in which
memory location methods, fields and objects are stored.

Suppose I have 2 classes

import java.util.*;
class ABC
{
int field;
List<Integer>l;
}   
class XYZ 
{
int x,y,z;
static int p;
void fun(ABC a){
    a.field = 10;
    a.l = new ArrayList<Integer>(10);
    a.l.add(10);
}
}   
public class Simulator{
public static void main(String[] arg){
    XYZ tmp_1 = new XYZ();
    ABC tmp_2 = new ABC();
    tmp_1.fun(tmp_2);
    System.out.println(tmp_2.l);
}

}

Now where will the memory be allocated for each of the data members,functions and objects be allocated ?

My thoughts are objects, data-members will be stored in Heap but I am not sure about functions and their data members ?

Answer 1

Here’s a breakdown of how the different things that you refer or allude to are stored:

• Local variables and method / constructor parameters can contain either primitive values or references to objects or arrays. (They cannot contain the objects or arrays themselves.) Locals and parameters are stored in activation frames (to use the JLS terminology), and these frames are stored on a thread’s stack. Thread stacks are non-heap memory in typical JVMs.

• Objects and arrays are represented in heap memory.

• Instance fields (containing primitive or reference values) are stored in objects, and hence in the heap.

• Array elements (either primitive or reference values) and the length of an array are stored in the array and hence in the heap.

• Static fields are stored in special frames called static frames. These frames are stored in the heap.

• The code of Java methods (in byte-code and native code form) is typically represented by code blocks that are stored in the heap.

---

Note that the above is based on what happens in a typical JVM. In fact, the Java Language Specification does not mandate that things are stored in a stack or a heap. The terms stack memory and heap memory hardly appear in the JLS at all, and it is conceivable that other memory organization schemes could be used.

Also, “the heap” is an over-simplification, because a HotSpot JVM / GC typically divides the heap into areas with different characteristics. For instance the “permgen” area of the heap (where static frames and code blocks are allocated) is only garbage collected rarely.