解决方案 »

  1.   

    当类将要被程序调用时,jvm会完成类的加载;当长时间不用时,jvm会启用gc机制来完成类的销毁。
      

  2.   

    类释不释放。释不释放,说的是实例化后的对象。
    释不释放,说的是数据类型。
    java 有那些数据类型?
      

  3.   

    我也试试来回答一下, 但程序用的带静态变量的类时,会先把静态变量放到内存中。 不管new多少个类,静态变量只在内存中保留一份,当类不在使用时或程序运行结束时,虚拟机的垃圾回收会释放这些内存吧
      

  4.   

    意思是用的时候才会加载?都没答在点子上。
    比如有一个方法中用到System.out.println("哈哈");,但是这个方法还没被被调用,那么这个System类中的静态变量会加载吗?谁能把这个跟我解释清楚了,我给他满分!
      

  5.   

    当Person类调用完之后,不在使用了,有垃圾回收来负责回收为这个类创建的内存,当然同时也会释放它的静态变量。下面是简单介绍JVM类加载初始化
    1. 类加载: 把.class文件加载到内存中,根据类中的元素保存到JVM内存的各个区域
    2. 连接: 验证字节码文件, 准备将类的静态变量进行分配内存空间、初始化默认值
    所有的JVM实现在首次主动调用类和接口的时候才会初始化他们
    3. 类的初始化:将类的静态变量赋予正确的初始值
    类的主动使用
    以下是视为主动使用一个类,其他情况均视为被动使用
    1):初学者最为常用的new一个类的实例对象(声明不叫主动使用)
    2):对类的静态变量进行读取、赋值操作的。
    3):直接调用类的静态方法。
    4):反射调用一个类的方法。
    5):初始化一个类的子类的时候,父类也相当于被程序主动调用了(如果调用子类的静态变量是从父类继承过来并没有复写的,那么也就相当于只用到了父类的东东,和子类无关,所以这个时候子类不需要进行类初始化)。
    6):直接运行一个main函数入口的类。静态变量的生命周期取决于类的生命周期,当类被加载的时候,静态变量被创建并分配内存空间,当类被卸载时,静态变量被摧毁,并释放所占有的内存参考:
    深入Java虚拟机JVM类加载初始化学习笔记 
    Java类的生存周期
      

  6.   

    如这个:class Person 
    {
    public static void main(String[] args) 
    {
    System.out.println("Hello World!");
    } public void show()
    {
    //注意这个show方法没有被调用,那么System类是否会加载到内存中?
    System.out.println("是否会加载?");
    }
    }
      

  7.   

    java中的对象都会分配在堆上,当这个对象上无引用指向时gc就会来回收,具体回收时间是不固定的
    因为gc回收线程的优先级很低,
      

  8.   

    如果问是否会加载,简单回答是,会加载到内存。1. Java程序执行的时候,会先启动java虚拟机, GC(内存回收)等等初始化工作, 然后类加载器加载程序的class和它import的class文件(lang包是默认导入的)到内存,也就是你的例子里面的System类也会加载到内存。 不知你所说的加载到内存是否是这个。 2. JVM有4个重要的内存区域
    方法区    常量池    堆区    栈区
    上面加载的类信息会保存到方法区。 如果你new Person()的话,JVM会根据类的信息给它分配内存(变量,我理解还有方法索引就是能找到这个方法在哪 )。当你调用方法是会在栈区中为方法分配局部变量等内存,当方法运行完这些分配的内存将被收回。 
    我也是先查的,然后按照我的理解组织起来来告诉你, 希望对你有所帮助
      

  9.   

    我说说我知道的东西 静态的变量在类初始化的时候就会先加载,然后等到这个类的实例不再参与程序的其他操作的时候 JVM的 GC就会把这个对象收走。我记得我看书是这样讲的。
      

  10.   

    所有的JVM实现在首次主动调用类和接口的时候才会初始化他们
    以下是视为主动使用一个类,其他情况均视为被动使用
    1):初学者最为常用的new一个类的实例对象(声明不叫主动使用)
    2):对类的静态变量进行读取、赋值操作的。
    3):直接调用类的静态方法。
    4):反射调用一个类的方法。
    5):初始化一个类的子类的时候,父类也相当于被程序主动调用了(如果调用子类的静态变量是从父类继承过来并没有复写的,那么也就相当于只用到了父类的东东,和子类无关,所以这个时候子类不需要进行类初始化)。
    6):直接运行一个main函数入口的类。也就是这些情况类会被初始化
      

  11.   

    应该是在执行前将Persion类加到内存的code segment后,静态变量就可以被调用了,它属于类的属性,跟随类的加载而加载,具有类的生命周期。我的个人理解。楼上说的都很强大。
      

  12.   

    参考:http://blog.csdn.net/zjclugger/article/details/7887186
      

  13.   

    我突然发现我理解错了,不是我想的那样。看这个例子:class StaticDemo
    {
    public static void main(String[] args) 
    {
    System.out.println("Hello World!");
    } public static void loadShow() 
    {
                                          //调用StaticTest类的show方法,但注意loadShow方法却没有被调用
    StaticTest.show();
    }
    }
    class StaticTest
    {
                       //静态代码块,类加载的时候加载(即会输出语句)
    static{
    System.out.println("加载了吗?");
    }
                       //类的静态方法
    public static void show() 
    {
    System.out.println("show");
    }
    }上面运行后结果为:
    Hello World!结论:只有当使用了(就是另一个类确确实实调用了)这个类的时候才会加载到内存中。即StaticTest类并没有因为StaticDemo类的loadShow方法中存在show方法而去加载到内存中。上面的说法还是有一定的问题的!欢迎拍砖!
      

  14.   

    还有一种也没加载到内存中,即:
    //主函数这样用,给变量赋null
    public static void main(String[] args) 
        {
            StaticTest s = null;
        }总结:只有当类被实实在在的用到了才会加载到内存中。
      

  15.   

    java虚拟机在加载程序的时候,并不会把所有的类都加载到内存,也不会把所有的静态变量加载到内存(假设你的java程序是20M,当你启动的时候,内存可能只占到10M),虚拟机首先会加载含有main方法的类(我这里说的是程用层的加载),这是入口函数,先加载该内的静态变量,静态块(顺序加载),接着是块,最后才是构造方法,然后再给成员赋值.整个过程结束后,得到一个类对象.所以,类的静态成员是当类加载的时候才会首次加载,而静态成员只加载一次.当类对象没有再被其他类调用的时候,虚拟机会调用GC(垃圾回收)把这个对象回收,并释放这个对象所占的内存,这里释放的是类的成员变量,并不会释放静态变量,静态变量加完一次之后就会永远留在内存里,直到程序结束.假设静态变量可以被回收,那下一次创建该类对象的时候,静态变量又会再加载一次,重新赋值,这就和静态变量只加载一次这个说法有冲突了.
    看代码package Test;class Go {
    static int i = 0;
    static {
    System.out.println("i第一次加载 i=" + i);
    i++;
    } Go() {
    System.out.println("创建新对象 i=" + i);
    }
    }
    package Test;public class Test {
    public Go g;
    }
    package Test;public class Test2 { public static void main(String[] args) {
    public static void main(String[] args) {
    Go g = new Go(); // 第一次加载Go类,静态变量加载第一次
    Go g1 = new Go();// 第二次加载Go类,静态变量不重新加载
    Test t = new Test();
    System.out.println(t.g.i);// 通过其他类调用静态变量
    g = null;// 释放第一次加载的类对象
    g1 = null;// 释放第二次加载的类对象
    System.out.println("g.i=" + g.i);// 输出静态变量
    System.out.println("g1.i=" + g1.i);// 输出静态变量
    }}输出结果为
    i第一次加载 i=0
    创建新对象 i=1
    创建新对象 i=1
    1
    g.i=1
    g1.i=1为什么会这样,自己再想想
      

  16.   

    你这个跟我说的不是一回事。
    你看我上面的例子:loadShow方法
      

  17.   


    你这个跟我说的不是一回事。
     你看我上面的例子:loadShow方法 
      

  18.   


    你这个跟我说的不是一回事。
     你看我上面的例子:loadShow方法 
    http://www.cnblogs.com/alexlo/archive/2013/03/05/2944573.html 这篇文章应该能帮到你.
      

  19.   


    你这个跟我说的不是一回事。
     你看我上面的例子:loadShow方法 
    http://www.cnblogs.com/alexlo/archive/2013/03/05/2944573.html 这篇文章应该能帮到你.
    我知道你这个没错,但是你说的这情况都是实实在在的调用过(也就是main方法运行的时候就调用了)。我当初在提问题的时候是想知道没实实在在调用过的会不会加载。现在我知道怎么回事了。