黑马程序员技术交流社区

标题: 内存加载 [打印本页]
作者: hmr8    时间: 2013-4-29 17:12
标题: 内存加载
有多个类，里面有静态、非静态的成员，在编译时怎么加载到内存的？
作者: 杨同旺    时间: 2013-4-29 21:02
类以及类里的成员,在编译时,由编译器加载到内存并编译成字节码文件.

类以及类的成员的字节码文件,由虚拟机的类加载器加载到内存并运行.

作者: 芦玉明    时间: 2013-4-29 21:06
1，栈区：各种原始数据类型的局部变量都是在栈上创建的，当程序退出该变量的作用范围的时候，这个变量的内存会被自动释放。
2，堆区：对象（包括数组）都是在堆中创建的。程序在运行的时候用new关键字来创建对象，对象创建时会在堆中为其分配内存。
3，方法区：内存在程序编译时就分配好了，比如静态变量。
作者: 伊廷文    时间: 2013-4-29 21:17
通过类加载器啊
作者: Sword    时间: 2013-4-30 01:49
数据成员可以分静态变量、非静态变量两种.
静态成员：静态类中的成员加入static修饰符,即是静态成员.可以直接使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态的成员..因为静态成员存在于内存,所以非静态成员可以直接访问类中静态的成员.

非成静态员：所有没有加Static的成员都是非静态成员,当类被实例化之后,可以通过实例化的类名进行访问..非静态成员的生存期决定于该类的生存期..而静态成员则不存在生存期的概念,因为静态成员始终驻留在内存中..

类所有内容加载顺序和内存中的存放位置：
利用语句进行分析。
1.Person p=new Person("zhangsan",20);
该句话所做的事情：
1.在栈内存中，开辟main函数的空间，建立main函数的变量 p。
2.加载类文件：因为new要用到Person.class,所以要先从硬盘中找到Person.class类文件，并加载到内存中。
加载类文件时，除了非静态成员变量（对象的特有属性）不会被加载，其它的都会被加载。
记住：加载，是将类文件中的一行行内容存放到了内存当中，并不会执行任何语句。---->加载时期，即使有输出语句也不会执行。
静态成员变量（类变量）  ----->方法区的静态部分
静态方法              
----->方法区的静态部分
非静态方法（包括构造函数）  ----->方法区的非静态部分
静态代码块 ----->方法区的静态部分
构造代码块 ----->方法区的静态部分

注意：在Person.class文件加载时，静态方法和非静态方法都会加载到方法区中，只不过要调用到非静态方法时需要先实例化一个对象
，对象才能调用非静态方法。如果让类中所有的非静态方法都随着对象的实例化而建立一次，那么会大量消耗内存资源，
所以才会让所有对象共享这些非静态方法，然后用this关键字指向调用非静态方法的对象。
作者: 符立波    时间: 2013-4-30 10:15
本帖最后由 符立波 于 2013-5-1 07:35 编辑

类的加载--->将类的class文件读入内存中，并为之创建一个Class对象，也就是说，当程序使用任何类时，系统都会为之建立一个Class对象
类的连接--->负责把类的二进制数据合并到JRE中，这又分为三个阶段：验证，准备，解析
验证：用于检测被加载的类是否有正确的内部结构，并和其他类协调一致(语法验证)
准备：为类的静态Field分配内存，并设置默认初始化值
解析：将类的二进制数据中的符号引用替换成直接引用

类的初始化--->主要是对静态Field进行初始化(①声明静态Field时指定初始化    ②使用静态代码块为静态Field指定初始化值)


作者: 黄玉昆    时间: 2013-4-30 23:28
符立波 发表于 2013-4-30 10:15
好好看下视频吧......

在提醒一下，如果不针对楼主的问题解答，将删帖，谢谢配合
作者: 火之意志    时间: 2013-5-23 12:10
首先在jvm中对于内存分为这样几个部分，栈内存，堆内存，方法区，本地方法区，寄存器，后两者是计算机底层的是有关C\C++的知识就不说了，内存加载过程中，对于多个类中，有静态、非静态的成员，在编译时是这样加载到内存中的：静态成员变量（类变量）和静态方法都是由static修饰，在加载类的时候优先于非静态的成员（变量和方法）加载，而非静态的成员什么时候加载呢？在创建该类的实例（即对象）的时候才会加载到内存，静态成员存在于方法区中的静态区中，创建的对象（即调用关键字new出来的）存在于堆内存中，栈内存是加载方法的，栈内存中包含方法内存定义的局部变量，调用哪个方法，哪个方法就会被加载到栈内存。总之，对于静态成员和非静态成员有加载的先后顺序，先加载的静态成员不能访问后加载的非静态成员，编译时会报错，后加载的可以访问先加载的。
作者: First    时间: 2013-5-26 17:59
   对象初始化顺序为：
* 1.为成员变量开辟空间并赋值为默认值
* 2.调用构造函数（为执行方法体）
* 3.调用父类构造函数
* 4.给成员变量赋初始值
* 5.执行代码块
* 6.执行构造函数方法体。

下面是具体的例子
  1. class A {
  2.         static int a1 = 1;
  3.         int a2 = 2;
  4.        
  5.         A(){
  6.                 System.out.println("基类A的构造函数：init A");
  7.                 System.out.println();
  8.         }
  9.         static {
  10.                 a1 = 10;
  11.                 System.out.println("基类A的静态代码块：static block a1 = " + a1);
  12.         }
  13.        
  14.         {
  15.                 a2 = 20;
  16.                 System.out.println("基类A的代码块：block a2 = " + a2);
  17.         }
  18.        
  19.         static void showA(){
  20.                 System.out.println("static showA = " + a1);
  21.         }
  22.        
  23.        
  24. }

  26. class B extends A{
  27.        
  28.         static int b1 = getB1();
  29.         int b2 = getB2();
  30.        
  31.         B(){
  32.                 System.out.println("父类B的构造函数：init B");
  33.                 System.out.println();
  34.         }
  35.        
  36.         static {
  37.                 b1 = 110;
  38.                 System.out.println("父类B的静态代码块：static block b1 = " + b1);
  39.         }
  40.        
  41.         {
  42.                 b2 = 220;
  43.                 System.out.println("父类B的代码块：block b2 = " + b2);
  44.         }
  45.        
  46.         static void showB(){
  47.                 System.out.println("static showB = " + b1);
  48.         }
  49.        
  50.         static int getB1(){
  51.                 System.out.println("父类B的静态成员初始化赋值函数：static getB1");
  52.                 return 11;
  53.         }
  54.        
  55.         int getB2(){
  56.                 System.out.println("父类B的成员初始化赋值函数：getB2");
  57.                 return 22;
  58.         }
  59. }

  61. class C extends B{
  62.        
  63.         static int c1 = getC1();
  64.         int c2 = getC2();
  65.        
  66.         C(){
  67.                 System.out.println("子类C的构造函数：init C");
  68.         }
  69.        
  70.         static {
  71.                 c1 = 1110;
  72.                 System.out.println("子类C的静态代码块：static block c1 = " + c1);
  73.                 System.out.println();
  74.         }
  75.        
  76.         {
  77.                 c2 = 2220;
  78.                 System.out.println("子类C的代码块：block c2 = " + c2);
  79.         }
  80.        
  81.         static void showC(){
  82.                 System.out.println("static showC = " + c1);
  83.         }
  84.        
  85.         static int getC1(){
  86.                 System.out.println("子类C的静态成员初始化函数：static getC1");
  87.                 return 111;
  88.         }
  89.        
  90.         int getC2(){
  91.                 System.out.println("子类C的成员初始化函数：getC2");
  92.                 return 222;
  93.         }
  94.        
  95. }

  97. public class Demo
  98. {
  99.         public static void main (String[] args){
  100.         C c = new C();
  101.         }
  102. }

  104. /* 输出结果：
  105. 基类A的静态代码块：static block a1 = 10
  106. 父类B的静态成员初始化赋值函数：static getB1
  107. 父类B的静态代码块：static block b1 = 110
  108. 子类C的静态成员初始化函数：static getC1
  109. 子类C的静态代码块：static block c1 = 1110

  111. 基类A的代码块：block a2 = 20
  112. 基类A的构造函数：init A

  114. 父类B的成员初始化赋值函数：getB2
  115. 父类B的代码块：block b2 = 220
  116. 父类B的构造函数：init B

  118. 子类C的成员初始化函数：getC2
  119. 子类C的代码块：block c2 = 2220
  120. 子类C的构造函数：init C


  123. //**************
  124. * 结论：
  125. * 静态成员函数-->静态成员变量-->静态代码块
  126. *
  127. * 成员函数-->成员变量-->代码块-->构造函数
  128. *
  129. * 因为成员变量是在赋值之前开辟的并被赋值为默认值 0，false，null;
  130. *
  131. *
  132. */
复制代码
作者: 136616244    时间: 2014-4-25 01:32
Sword 发表于 2013-4-30 01:49
数据成员可以分静态变量、非静态变量两种.
静态成员：静态类中的成员加入static修饰符,即是静态成员.可以 ...

创建对象的时候是根据方法区中的类信息创建对象的，如果加载的时候不加载非静态成员变量进方法区，那怎么实例化成员变量呢？




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2