java的一个问题

Question

class Mug {
  Mug(int er) {
    System.out.println("Mug(" + er + ")");
  }
  void f(int er) {
    System.out.println("f(" + er + ")");
  }
}public class Mugs {
  Mug c1;
  Mug c2;
  {
    c1 = new Mug(1);
    c2 = new Mug(2);
    System.out.println("c1 & c2 initialized");
  }
  Mugs() {
    System.out.println("Mugs()");
  }
  public static void main(String[] args) {
    System.out.println("Inside main()");
    Mugs x = new Mugs();
  }
} 
为什么输出顺序为
Inside main()
Mug(1)
Mug(2)
c1&c@ initialized
Mugs()
我自己想的与运行的不一样啊！

Answer 1

程序先从main()函数开始执行，所以要加载Mugs.class,静态初始化在此进行，故先输出Inside main()。
然后是初始化基本类型和引用。
{ c1   =   new   Mug(1);
  c2   =   new   Mug(2); 
  System.out.println("c1   &   c2   initialized"); 
 } 
是一个静态初始化块。
最后执行构造器。
thinking in java 第四章有介绍，可以参考一下。

Answer 2

顺序是从main()进去，输出Inside   main()，如果有静态块必须先执行，没有执行方法外的程序块，执行Mug   c1; Mug   c2; ->再执行c1   =   new   Mug(1); 构造输出Mug(1) ，->c2   =   new   Mug(2);构造输出Mug(2) ,再执行 System.out.println("c1   &   c2   initialized"); 最后自己的
构造函数．因为上面的类除了方法就是构造函数，没有其他的东西．

Answer 3

程序从main函数开始执行,
System.out.println("Inside   main()");    -->   Inside   main() //1Mugs   x   =   new   Mugs(); //这一句有的麻烦.1、类只有在使用New调用创建的时候才会被JAVA类装载器装入,不要认为在这句之前内存中已经有了Mugs类了.
2、JAVA类首次装入时，会对静态成员变量或方法进行一次初始化,但方法不被调用是不会执行的.
静态成员变量和静态初始化块级别相同，非静态成员变量和非静态初始化块级别相同。
先初始化父类的静态代码--->初始化子类的静态代码-->初始化父类的非静态代码--->初始化父类构造函数--->初始化子类非静态代码--->初始化子类构造函数
有了这个初始化顺序,应该就能推出这样的结果了.你可以添加一个静态的代码块看看效果.在代码块前加static关键字就是静态代码块.

Answer 4

to zcyjava程序先从main()函数开始执行，所以要加载Mugs.class,静态初始化在此进行，故先输出Inside   main()。 
然后是初始化基本类型和引用。 
{   c1       =       new       Mug(1); 
    c2       =       new       Mug(2);   
    System.out.println("c1       &       c2       initialized");   
  }   
是一个静态初始化块。 
最后执行构造器。 
thinking   in   java   第四章有介绍，可以参考一下。程序先从main()函数开始执行，所以要加载Mugs.class,静态初始化在此进行，故先输出Inside   main()。 不是在这时加载Mugs类的.而是在new时加载的.
{   c1       =       new       Mug(1); 
    c2       =       new       Mug(2);   
    System.out.println("c1       &       c2       initialized");   
  }   
是一个静态初始化块。 不是一个静态代码块.多多指教.

Answer 5

to cursor_wang 执行Mug       c1;   Mug       c2;   -> 再执行c1       =       new       Mug(1);   构造输出Mug(1)   ，-> c2       =       new       Mug(2);构造输出Mug(2)   ,再执行   System.out.println("c1       &       c2       initialized");   最后自己的 
构造函数．
这样的说法貌似是按照代码的顺序  顺序执行的.这个顺序上面我也有点糊涂.

Answer 6

不好意思,之前我的回答有点问题.1、类只有在使用New调用创建的时候才会被JAVA类装载器装入,不要认为在这句之前内存中已经有了Mugs类了. 启动类(含main方法的类),在命令行中执行命令 :java Mugs 时就加载了.这句话只针对非启动类而言.

Answer 7

大家研究一下类的初始化顺序,修改后的代码.class   Mug   { 
    Mug(int   er)   { 
        System.out.println("Mug("   +   er   +   ")"); 
    } 
    void   f(int   er)   { 
        System.out.println("f("   +   er   +   ")"); 
    } 
} class   Mugs   { 
    public   static   void   main(String[]   args)   { 
        System.out.println("Inside   main()"); 
        Mugs   x   =   new   Mugs(); 
    } 
    Mugs()   { 
        System.out.println("Mugs()"); 
    } 
    { 
        c1 = new Mug(3);
        c2 = new Mug(4);
        c3 = new Mug(5);
        System.out.println("c1   &   c2   initialized");
    }    
Mug c1 = new Mug(1);
Mug c2 = new Mug(2);
Mug c3 = new Mug(6);
static{System.out.println("Outside main()");}
static Mug c0=new Mug(0);
}执行结果:Outside main()
Mug(0)
Inside   main()
Mug(3)
Mug(4)
Mug(5)
c1   &   c2   initialized
Mug(1)
Mug(2)
Mug(6)
Mugs()从输出的4,5,6行来看,语句 Mug c1 = new Mug(1);被分成两部分来执行了.

Answer 8

程序先从main()函数开始执行，然后按照自顶向下的程序输出规则，故会得到如此输出顺序

Answer 9

请问
class   Mug   { 
    Mug(int   er)   { 
        System.out.println("Mug("   +   er   +   ")"); 
    } 
    void   f(int   er)   { 
        System.out.println("f("   +   er   +   ")"); 
    } 
} public   class   Mugs   { 
    Mug   c1; 
    Mug   c2; 
    { 
        c1   =   new   Mug(1); 
        c2   =   new   Mug(2); 
        System.out.println("c1   &   c2   initialized"); 
    }     
    Mugs()   { 
        System.out.println("Mugs()"); 
    } 
    public   static   void   main(String[]   args)   { 
        System.out.println("Inside   main()"); 
        Mugs   x   =   new   Mugs(); 
    } 
} 
和
class   Mug   { 
    Mug(int   er)   { 
        System.out.println("Mug("   +   er   +   ")"); 
    } 
    void   f(int   er)   { 
        System.out.println("f("   +   er   +   ")"); 
    } 
} class   Mugs   { 
    public   static   void   main(String[]   args)   { 
        System.out.println("Inside   main()"); 
        Mugs   x   =   new   Mugs(); 
    } 
    Mugs()   { 
        System.out.println("Mugs()"); 
    } 
    { 
        c1 = new Mug(3);
        c2 = new Mug(4);
        c3 = new Mug(5);
        System.out.println("c1   &   c2   initialized");
    }    
    Mug c1 = new Mug(1);
    Mug c2 = new Mug(2);
    Mug c3 = new Mug(6);
    static{System.out.println("Outside main()");}
    static Mug c0=new Mug(0);
}
中的红色部分和匿名的inner class的区别是什么?   谢谢指教

Answer 10

补楼上的:
程序执行顺序:如果在main()中new调用创建,先执行main class父类函数初始化部分 ,再执行父类函数构造函数,其次main class初始化部分,最后是main class构造函数.

Answer 11

我觉得，jvm在加载类时候，首先执行main函数，相信大家都知道这个
然后调用静态初始化块，如果你new 了一个对象，调用对应类的构造方法，默认是无参的
所以，就是你这样的结果了！

Answer 12

首先static块-》main函数 -》实列块-》构造函数

Answer 13

2楼的谢了.
学了C++再学JAVA容易混淆.
不过还是蛮轻松的．

Answer 14

执行顺序：
1.类的静态代码块
2.main函数
3.非静态代码块
4.构造
public class Person {
    {
        System.out.println("This is code block1.");
    }
    static{
        System.out.println("This is static code block1");
    }
    public Person() {
        System.out.println("This is struct method.");
    }
    public static void main(String[] args){
        System.out.println("This is main method.");
        Person p1=new Person();
        Person p2=new Person();
    }
}
输出：
This is static code block1
This is main method.
This is code block1.
This is struct method.
This is code block1.
This is struct method.

Answer 15

    { 
        c1   =   new   Mug(1); 
        c2   =   new   Mug(2); 
        System.out.println("c1   &   c2   initialized"); 
    }
请问这个没有什么名字只有括号的函数是什么啊？
谁能给我详细讲解一下。

Answer 16

 {   
                c1       =       new       Mug(1);   
                c2       =       new       Mug(2);   
                System.out.println("c1       &       c2       initialized");   
        } 
我也想知道这个是什么,以前怎么没碰到过,没名字,也没关键字,哪位能讲一下吗?