黑马程序员技术交流社区

标题: 关于类加载的问题 [打印本页]
作者: 蒋欣琦    时间: 2012-11-2 14:30
标题: 关于类加载的问题
加载是在什么时期加载的呢？编译时期就加载了还是运行时再加载？静态方法随着类的加载而加载，先于对象，下面程序当A类加载时，成员变量a和成员函数show也会加载，那么当程序运行时刻，A.show()调用时，a=new A()这个初始化什么时候执行呢？
class A
{
       static A a=new A();
       public static A show()
      {
       return a;
      }
}
class B
{
       public static void main(String[] args)
      {
          A a=A.show();
      }
}
作者: 奋斗的青春    时间: 2012-11-2 14:46
本帖最后由 吴愿涛 于 2012-11-2 15:07 编辑

以前记得static代码块貌似是Java类加载过程中优先级最高的，但是最近几天写代码发现不是这样的，因为static变量的优先级要比static代码块高得多，所以因此我犯了不少错误，下面以一个例子来说明一下一个类初始化为对象的时候的加载过程：
  1. package day0508;
  2. public class Test4 {
  3. /**
  4. * @param args
  5. */
  6. private static A a = new A();
  7. private final F f = new F();
  8. private B b = new B();
  9. static{
  10. System.out.println("c");
  11. }
  12. public Test4(){
  13. System.out.println("Test");
  14. }
  15. public static void main(String[] args) {
  16. Test t = new Test();
  17. try {
  18. Class.forName("day0508.Test4");
  19. } catch (ClassNotFoundException e) {
  20. // TODO: handle exception
  21. e.printStackTrace();
  22. }
  23. }
  24. class A{
  25. public A(){
  26. System.out.println("A");
  27. }
  28. }
  29. class B{
  30. public B(){
  31. System.out.println("B");
  32. }
  33. }
  34. class F{
  35. public F(){
  36. System.out.println("F");
  37. }
  38. }
  39. }
复制代码
直接运行Test t = new test();这句话，运行结果为
A  F  c  B  Test 所以是先static变量，然后是static的代码块，然后才是普通变量，最后是构造函数
如果是运行Class.forName()函数的话，运行结果为
A  F  c 还是这样，先是static变量，然后才是static代码块，所以那种对于class.Forname加载类，只调用static代码块的误区要克服，因为还有一个static代码块在等着你，呵呵，我得记录下来以示警戒。
作者: 张超    时间: 2012-11-2 15:05

1 编译是将java程序编译为jvm可执行代码（是一个翻译的过程，并不会执行程序，就像对于老外写的文章（这个就相当于.java的文件）我们看不懂，就让人翻译为我们看得懂的汉字(就相当于.class)。）。
2 运行：编译器把java程序翻译为java字节码后，这个时候的工作就有解释器来完成，也就是所说的运行，解释器在执行过程中他会分为3步：代码的装入 代码的校验 代码的执行。而你问的关于类的加载其实就是解释器执行过程中的第一步.
3  当调用A.show()时，这个时候就开始加载A 类了，也就是按照加载类的规则进行加载，而你的这个a刚好是静态的所以会被第一时间加载，这就是为什么类名能够调用静态变量的原因。
作者: 种生祥    时间: 2012-11-2 15:17
类在用的时候才加载，也就是建立对象，调用函数时才加载
作者: 林晓泉    时间: 2012-11-2 15:48

  2. public class Test4 {

  4. /**

  6. * @param args

  8. */

  10. private static A a1 = new A(1);

  12. private final F f = new F();

  14. private B b = new B();

  16. static{
  17. a1=new A(3);
  18. a2=new A(4);
  19. a3=new A(5);
  20. System.out.println("c");

  22. }
  23. private static A a2 = new A(2);
  24. private static A a3;
  25. public Test4(){

  27. System.out.println("Test");

  29. }

  31. public static void main(String[] args) {

  33. Test4 t = new Test4();
  34.   
  35. }
  36. }
  37. class A{

  39. public A(int i){

  41. System.out.println("A"+i);

  43. }

  45. }

  47. class B{

  49. public B(){

  51. System.out.println("B");

  53. }

  55. }

  57. class F{

  59. public F(){

  61. System.out.println("F");

  63. }

  65. }
复制代码
看看，这个可以直接编译运行
这种情况一直不明白怎么回事，在论坛上求解的时候没有一个符合的



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