黑马程序员技术交流社区

标题: 这个地方不太懂，帮解决下疑惑？ [打印本页]
作者: 张凯    时间: 2012-7-22 09:04
标题: 这个地方不太懂，帮解决下疑惑？
本帖最后由 张凯 于 2012-7-23 07:09 编辑
  1. package ch08;

  3. class MyBook{
  4. MyBook(int maker){
  5. System.out.println("MyBook("+maker+")");
  6. }
  7. void foo(int maker){
  8. System.out.println("foo("+maker+")");
  9. }
  10. }

  12. class MyPackage{
  13. static MyBook b1 = new MyBook(1);
  14. MyPackage(){
  15. System.out.println("MyPackage()");
  16. b2.foo(1);
  17. }
  18. void foo2(int maker){
  19. System.out.println("foo2("+maker+")");
  20. }
  21. static MyBook b2 = new MyBook(2);
  22. }

  24. class MyRoom{
  25. MyBook b3 = new MyBook(3);
  26. static MyBook b4 = new MyBook(4);
  27. MyRoom(){
  28. System.out.println("MyRoom()");
  29. b4.foo(2);
  30. }
  31. void foo3(int maker){
  32. System.out.println("foo3("+maker+")");
  33. }
  34. static MyBook b5 = new MyBook(5);
  35. }
  36. public class StaticIni{
  37. public static void main(String[] args){
  38. System.out.println("Creating new MyRoom() in main");
  39. new MyRoom();
  40. System.out.println("Creating new MyRoom() in main");
  41. new MyRoom();
  42. t2.foo2(1);
  43. t3.foo3(1);
  44. }
  45. static MyPackage t2 = new MyPackage();
  46. static MyRoom t3 = new MyRoom();
  47. }
复制代码
我的疑惑是在这里
class MyPackage{
static MyBook b1 = new MyBook(1);
MyPackage(){
System.out.println("MyPackage()");
b2.foo(1);
}
void foo2(int maker){
System.out.println("foo2("+maker+")");
}
static MyBook b2 = new MyBook(2);
}

b2这个对象为什么先使用b2.foo(1);然后再声明引用static MyBook b2 = new MyBook(2);
这样不是违反了规则了吗？
作者: 孙飞    时间: 2012-7-22 09:33
没有啊，因为静态显示初始化是优先于构造函数执行的，当MyPackage(){}这个构造函数执行的时候，static MyBook b2 = new MyBook(2); 都已经执行过了。顺便给你说一下，代码执行的顺序，先是静态初始化，然后是静态代码块，然后是普通成员变量的默认初始化，然后是普通成员变量的显式初始化，然后是对对象进行构造代码块初始化，然后再是对象相应的构造函数初始化。所以static MyBook b2 = new MyBook(2); 虽然在下面放，但先执行的。
作者: 王舜民    时间: 2012-7-22 09:41
看了这个。我也晕了，求强人回答一下。我步骤这也有错么？

class MyBook{                                                           // //3
MyBook(int maker){
System.out.println("MyBook("+maker+")");
}
void foo(int maker){
System.out.println("foo("+maker+")");              ////4
}
}

class MyPackage{
static MyBook b1 = new MyBook(1);
MyPackage(){
System.out.println("MyPackage()");
b2.foo(1);
}
void foo2(int maker){
System.out.println("foo2("+maker+")");
}
static MyBook b2 = new MyBook(2);            // // 2
}

class MyRoom{
MyBook b3 = new MyBook(3);
static MyBook b4 = new MyBook(4);
MyRoom(){
System.out.println("MyRoom()");
b4.foo(2);
}
void foo3(int maker){
System.out.println("foo3("+maker+")");
}
static MyBook b5 = new MyBook(5);
}
public class StaticIni{
public static void main(String[] args){
System.out.println("Creating new MyRoom() in main");
new MyRoom();
System.out.println("Creating new MyRoom() in main");
new MyRoom();
t2.foo2(1); //                     ///// 1
t3.foo3(1);
}
static MyPackage t2 = new MyPackage();
static MyRoom t3 = new MyRoom();
}
作者: 王舜民    时间: 2012-7-22 09:54
feigecal 发表于 2012-7-22 09:33
没有啊，因为静态显示初始化是优先于构造函数执行的，当MyPackage(){}这个构造函数执行的时候，static MyBo ...

能详细讲一下，这个顺序吗？就是先执行哪边的
作者: 孙飞    时间: 2012-7-22 10:20
王舜民 发表于 2012-7-22 09:54
能详细讲一下，这个顺序吗？就是先执行哪边的

静态初始化只一次，这一点要注意，下面是顺序
class MyBook
{
MyBook(int maker)
{
  System.out.println("MyBook("+maker+")"); //3   //5   // 11  // 13  //15
 }
void foo(int maker)
{
  System.out.println("foo("+maker+")"); //8  //18
 }
}
class MyPackage
{
static MyBook b1 = new MyBook(1); //2
 MyPackage()
{
  System.out.println("MyPackage()"); //6
  b2.foo(1);                         //7
 }
void foo2(int maker)
{
  System.out.println("foo2("+maker+")"); //30
 }
static MyBook b2 = new MyBook(2); //4
}
class MyRoom
{
MyBook b3 = new MyBook(3); // 14   //21   //26
 static MyBook b4 = new MyBook(4); //10
 MyRoom()
{
  System.out.println("MyRoom()"); // 16   //22   //27
  b4.foo(2);                        //17  //23   //28
 }
void foo3(int maker)
{
  System.out.println("foo3("+maker+")"); //32
 }
static MyBook b5 = new MyBook(5); // 12
}
public class StaticTni
{
public static void main(String[] args)
{
  System.out.println("Creating new MyRoom() in main"); //19
  new MyRoom();                                        //20
  System.out.println("Creating new MyRoom() in main");   //24
  new MyRoom();                                        //25
  t2.foo2(1);                                         //29
  t3.foo3(1);                                        //31
 }
static MyPackage t2 = new MyPackage(); // 1
 static MyRoom t3 = new MyRoom(); //  9
}
我就纳闷了，不就想看顺序吗，用搞这么多吗，看着太费劲
作者: 林康春    时间: 2012-7-22 11:01
代码执行顺序：

     程序加载class文件，加载了这个public class StaticIni 类后，立刻进行静态代码块的部分
static MyPackage t2 = new MyPackage();
static MyRoom t3 = new MyRoom();
先读  static MyPackage t2 = new MyPackage();
加载 MyPackage 这个类，同样的先执行静态代码块一：static MyBook b1 = new MyBook(1); 二：static MyBook b2 = new MyBook

(2);
对一：同样的加载MyBook 这个类，先执行静态代码块，这MyBook 类中没有静态代码块，因此进行实例对象初始化，执行
MyBook(int maker){ System.out.println("MyBook("+maker+")"); }这句，打印出MyBook(1)；
对二：因为在一中已经给类MyBook 加载了，因此二的代码直接进行实例对象初始化，打印出MyBook(2)
现在，到了对MyPackage 这个类进行实例对象初始化了，相应的打印出MyPackage()，再执行里面构造函数的下一条语句b2.foo(1);
相应的去调用这个方法，执行MyBook类中的void foo(int maker){System.out.println("foo("+maker+")"); }，打印出foo(1);


到此，执行完static MyPackage t2 = new MyPackage(); 后，接桌执行tatic MyRoom t3 = new MyRoom()
先加载MyRoom 这个类，成员变量默认初始化，即MyBook b3=null,然后静态代码的执行 一 ：static MyBook b4 = new MyBook(4);

二： static MyBook b5 = new MyBook(5);
对一：因为在上面已经给这个类加载了，同理的直接进行实例对象初始化，打印出MyBook(4)
对二：和上面的一  一样，打印出MyBook(5)
现在，来到了对new MyRoom()实例对象初始化，相应的执行构造函数的语句MyRoom(){ System.out.println("MyRoom()"); b4.foo

(2); }，先打印出MyRoom()，再执行里面构造函数的下一条语句b4.foo(2)，打印出foo(2)

好了，到此，进入主函数main()里面了，先执行System.out.println("Creating new MyRoom() in main"); ，打印出
Creating new MyRoom() in main
然后执行new MyRoom();
这个类MyRoom已经加载了，因此只执行实例对象初始化，先显示成元变量MyBook b3，即b3=new MyBook (),那这样就要访问了MyBook

这个类，这个类已经加载了，因此只执行实例对象初始化，即执行MyBook(int maker){System.out.println("MyBook("+maker+")");
}，打印出Mybook(3)  .再执行new MyRoom()对应的构造函数语句，得到打印出MyRoom()，调用b4.foo(2)语句时，得到打印出foo(2)

继续，执行System.out.println("Creating new MyRoom() in main"); 打印出Creating new MyRoom() in main
继续执行下面的new MyRoom();
这和上面的一样，得到打印的结果： MyBook(3)  MyRoom() foo(2)
最后执行 t2.foo2(1); t3.foo3(1); 这两句
得到打印结果foo2(1)和foo3(1)



作者: 王舜民    时间: 2012-7-22 11:03
feigecal 发表于 2012-7-22 10:20
静态初始化只一次，这一点要注意，下面是顺序
class MyBook
{

谢谢。终于看清楚了。你就是按照
“先是静态初始化，然后是静态代码块，然后是普通成员变量的默认初始化，
然后是普通成员变量的显式初始化，然后是对对象进行构造代码块初始化，然后再是对象相应的构造函数初始化。”
一步步慢慢分析的对吧？
我太浮躁了，谢谢！
作者: 杨朔    时间: 2012-7-22 12:19
一道简单题，非要弄那么长的代码，一个执行顺序的问题。首先你要了解内存分析。首先，一个程序开始编译时，
1：把该文件的。class文件加载到方法区，此时所有的静态方法和静态常量也加载到方法区，
2：main方法入栈按照顺序执行
具体的没写，你自己多看看吧，要想学这个，就先把你的static学好，还有内存分析
作者: 张凯    时间: 2012-7-23 07:09
feigecal 发表于 2012-7-22 09:33
没有啊，因为静态显示初始化是优先于构造函数执行的，当MyPackage(){}这个构造函数执行的时候，static MyBo ...

原来静态显示初始化是优先于构造函数执行的，谢谢了。
作者: 魏-玉-彪    时间: 2012-7-23 19:46
static MyBook b2 = new MyBook(2);  这个静态方法在其他代码执行前已经加载执行了，和在程序中出现的顺序没关系



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