¿Qué es la memoria de pila?
La pila en Java es una sección de memoria que contiene métodos, variables locales y variables de referencia. La memoria de pila siempre se referencia en el orden de último en entrar, primero en salir. Las variables locales se crean en la pila.
¿Qué es Heap Memory?
Heap es una sección de la memoria que contiene objetos y también puede contener variables de referencia. Las variables de instancia se crean en el montón
Asignación de memoria en Java
La asignación de memoria en Java es el proceso en el que las secciones de memoria virtual se separan en un programa para almacenar las variables y las instancias de estructuras y clases. Sin embargo, la memoria no se asigna a un objeto en la declaración, sino que solo se crea una referencia. Para la asignación de memoria del objeto, se usa el método new (), por lo que al objeto siempre se le asigna memoria en el montón.
La asignación de memoria de Java se divide en las siguientes secciones:
- Montón
- Apilar
- Código
- Estático
Esta división de la memoria es necesaria para su gestión eficaz.
- La sección de código contiene su código de bytes .
- La sección Pila de la memoria contiene métodos, variables locales y variables de referencia.
- La sección Heap contiene objetos (también puede contener variables de referencia).
- La sección Estática contiene datos / métodos estáticos .
Diferencia entre variable local y de instancia
La variable de instancia se declara dentro de una clase pero no dentro de un método
class Student{int num; // num is instance variablepublic void showData{}
Las variables locales se declaran dentro de un método, incluidos los argumentos del método .
public void sum(int a){int x = int a + 3;// a , x are local variables;}
Diferencia entre pila y montón
Haga clic aquí si el video no es accesible
Tomemos un ejemplo para entender esto mejor.
Considere que su método principal que llama al método m1
public void m1{int x=20}
En la pila Java, se creará un marco a partir del método m1.
La variable X en m1 también se creará en el marco de m1 en la pila. (Ver imagen a continuación).
El método m1 llama al método m2. En la pila Java, se crea un nuevo marco para m2 encima del marco m1.
Las variables byc también se crearán en un marco m2 en una pila.
public void m2(int b){boolean c;}
El mismo método m2 está llamando al método m3. Nuevamente, se crea un marco m3 en la parte superior de la pila (vea la imagen a continuación).
Ahora digamos que nuestro método m3 está creando un objeto para la clase "Cuenta", que tiene dos instancias variables int p e int q.
Account {Int p;Int q;}
Aquí está el código para el método m3
public void m3(){Account ref = new Account();// more code}
El estado de cuenta new Account () creará un objeto de cuenta en el montón.
La variable de referencia "ref" se creará en una pila Java.
El operador de asignación hará una variable de referencia para apuntar al objeto en el montón.
Una vez que el método ha completado su ejecución. El flujo de control volverá al método de llamada. Que en este caso es el método m2.
La pila del método m3 se vaciará.
Dado que la variable de referencia ya no apuntará al objeto en el montón, sería elegible para la recolección de basura.
Una vez que el método m2 ha completado su ejecución. Se extraerá de la pila y todas sus variables se eliminarán y ya no estarán disponibles para su uso.
Lo mismo ocurre con el método m1.
Finalmente, el flujo de control volverá al punto de inicio del programa. Que suele ser el método "principal".
¿Qué pasa si Object tiene una referencia como su variable de instancia?
public static void main(String args[]) {A parent = new A(); //more code } class A{ B child = new B(); int e; //more code } class B{ int c; int d; //more code }
En este caso, la variable de referencia "child" se creará en el montón, que a su vez apuntará a su objeto, algo parecido al diagrama que se muestra a continuación.
Resumen:
- Cuando se llama a un método, se crea un marco en la parte superior de la pila.
- Una vez que un método ha completado la ejecución, el flujo de control vuelve al método de llamada y su marco de pila correspondiente se vacía.
- Las variables locales se crean en la pila
- Las variables de instancia se crean en el montón y son parte del objeto al que pertenecen.
- Las variables de referencia se crean en la pila.
