java编程思想（四）中的一道题

Question

class Cup{
Cup(int er){
System.out.println("Cup("+er+")");
}
void f(int er){
System.out.println("f("+er+")");
}
}
class Cups{
static Cup c1;
static Cup c2;
static {
c1 = new Cup(1);
c2 = new Cup(2);
}
Cups(){
System.out.println("Cups()");
}
}
public class ExplicitStatic {
public static void main(String[] args) {
// TODO Auto-generated method stub
        System.out.println("Inside main()");
        Cups.c1.f(99);
}
    static Cups x = new Cups();
    static Cups y = new Cups();
}
希望高手解释一下程序运行顺序和static｛｝的用法？

Answer 1

static 是静态块   在类加载的时候就已经执行了 
这个顺序有点复制   你自己多加一些System.out.println(1);System.out.println(2);来测试一下到底先执行的是什么

Answer 2

嗯，其实，你完全可以将这个程序运行一下，然后看结果自己来分析！
运行结果：
Cup(1)
Cup(2)
Cups()
Cups()
Inside main()
f(99)
说明在执行main()方法中的语句之前，它是先执行所有的静态变量的创建。

Answer 3

class Cup{
Cup(int er){
System.out.println("Cup("+er+")");
}
void f(int er){
System.out.println("f("+er+")");
}
}
class Cups{
static Cup c1;
static Cup c2;
static {
System.out.println("c1 = new Cup(1)");
  c1 = new Cup(1);
  System.out.println("c1 = new Cup(2)");
  c2 = new Cup(2);
}
Cups(){
System.out.println("Cups()");
}
}
public class ExplicitStatic {
public static void main(String[] args) {
// TODO Auto-generated method stub
  System.out.println("Inside main()");
  Cups.c1.f(99);
}
  static Cups x = new Cups();
  static Cups y = new Cups();
}
输出结果。。
c1 = new Cup(1)
Cup(1)
c1 = new Cup(2)
Cup(2)
Cups()
Cups()
Inside main()
f(99)静态块先初始化吧。。多加几个system.out就看出来了。。
一起学习了。

Answer 4

程序在进入main方法之前会先加载所有有关的静态的东西，并且只加载一次
所有先会到这里
1.static Cups x = new Cups();
2.static Cups y = new Cups();
先加载上面的第第一步static Cups，这时候会加载Cups类，此时的Cups中也存在静态代码块，所有又去加载Cups中的静态代码，就会进入下面
3.static Cup c1;
4.static Cup c2;
5.static {
6.c1 = new Cup(1);
7.c2 = new Cup(2);
  }
依次3,4，5,6到这来的时候就会new Cup(1)，创建Cup对象，调用其被重载的构造方法，
Cup(int er){
System.out.println("Cup("+er+")");
}
打印Cup(1)，
完成后进入第七步，跟上面一样，此时打印Cup(2)
此时Cups中的静态代码加载完毕，返回到第一步，此时new Cups(),调用cups()的构造方法
Cups(){
8.System.out.println("Cups()");
}
即进入第八步，打印Cups()
完成后进入第二步，static Cups y = new Cups();此时Cups中的静态代码在之前第一次已经加载过，所以不会再次加载，而是继续new Cups(),就又打印出Cups()，完成后进入main()方法
System.out.println("Inside main()");
  Cups.c1.f(99);
打印Inside main()
然后调用Cups.c1.f(99),打印f(99)
所以结果是:
Cup(1)
Cup(2)
Cups()
Cups()
Inside main()
f(99)
主要的就是在main方法执行前会加载所有的静态代码，并且只加载一次。

Answer 5

 先运行静态方法，然后就构造器，然后方法域，然后就是MIAN函数的顺序

Answer 6

static是类加载的时候调用，它是类调用的。而其他是对象调用的。  static Cups x = new Cups();
  static Cups y = new Cups();
这在mian下面，执行mian就 调用这个。
然后执行Cups  里面静态变量要记住，静态变量只初始化一次，而且是类调用的。你有认真看think in java。
我每天就看几页 ，积累一个多月也看了170多页了。。