标签: static-block

据我所知,"静态初始化块"用于设置静态字段的值,如果不能在一行中完成的话.

但我不明白为什么我们需要一个特殊的块.例如,我们将一个字段声明为静态(没有值赋值).然后编写几行代码,生成并为上面声明的静态字段赋值.

为什么我们需要在一个特殊的块这样的行这样的:static {...}？

我有两个班级父母和孩子

public class Parent {    
    public Parent() {
        System.out.println("Parent Constructor");
    }    
    static {
        System.out.println("Parent static block");    
    }    
    {
        System.out.println("Parent initialisation  block");
    }
}

public class Child extends Parent {    
    {
        System.out.println("Child initialisation block");
    }
    static {
        System.out.println("Child static block");
    }

    public Child() {
        System.out.println("Child Constructor");
    }    
    public static void main(String[] args) {
        new Child();    
    }
}

上面代码的输出将是

Parent static block
Child static block
Parent initialization  block
Parent Constructor
Child initialization block
Child Constructor

为什么Java按该顺序执行代码？确定执行顺序的规则是什么？

可能重复:
静态初始化块

请考虑以下代码:

public class Test {
    {
        System.out.println("Empty block");
    }
    static {
        System.out.println("Static block");
    }
    public static void main(String[] args) {
        Test t = new Test();
    }
}

我们知道首先执行静态块,然后执行空块.但问题是我从来没有能够理解空块的实际效用.任何人都可以展示一个真实的例子 -

• 无论静态和空正在使用的块
• 无论静态和空块具有不同的事业

我对Java的座右铭是"仅仅因为Java有静态块,它并不意味着你应该使用它们." 除了笑话之外,Java中有很多技巧会让测试成为一场噩梦.我最讨厌的两个是匿名类和静态块.我们有很多使用静态块的遗留代码,这些是我们编写单元测试的烦恼之一.我们的目标是能够为依赖于此静态初始化的类编写单元测试,并且代码更改最少.

到目前为止,我对同事的建议是将静态块的主体移动到私有静态方法中并调用它staticInit.然后可以从静态块内调用此方法.对于单元测试,依赖于此类的另一个类可以轻松地staticInit使用JMockit进行模拟而不执行任何操作.我们在示例中看到这一点.

public class ClassWithStaticInit {
  static {
    System.out.println("static initializer.");
  }
}

将改为

public class ClassWithStaticInit {
  static {
    staticInit();
  }

  private static void staticInit() {
    System.out.println("static initialized.");
  }
}

这样我们就可以在JUnit中执行以下操作.

public class DependentClassTest {
  public static class MockClassWithStaticInit {
    public static void staticInit() {
    }
  }

  @BeforeClass
  public static void setUpBeforeClass() {
    Mockit.redefineMethods(ClassWithStaticInit.class, MockClassWithStaticInit.class);
  }
}

然而,这种解决方案也有其自身的问题.您无法在同一个JVM上运行DependentClassTest,ClassWithStaticInitTest因为您实际上希望运行静态块ClassWithStaticInitTest.

你完成这项任务的方式是什么？或者你认为哪种更好,非基于JMockit的解决方案更干净？

我已经了解到,在Java中,静态块在初始化类时执行,并且在构造每个类的实例之前执行实例块.我总是在实例块之前看到要执行的静态块.为什么案件相反enums？

任何人都可以请解释示例代码的输出:

enum CoffeeSize {

    BIG(8), LARGE(10),HUGE(12),OVERWHELMING();
    private int ounces ;

    static {
        System.out.println("static block ");
    }
    {
        System.out.println("instance block");
    }

    private CoffeeSize(int ounces){
        this.ounces = ounces;
        System.out.println(ounces);
    }
    private CoffeeSize(){
        this.ounces = 20;
        System.out.println(ounces);
    }

    public int getOunces() {
        return ounces;
    }
} 

输出:

实例块
8
实例块
10
实例块
12
实例块
20
静态块

当我y通过使用Checks.y(Checks作为子类)调用静态变量时,不执行静态块,y并且不会更新值.

class Par {
    static int y = 4;
}

class Checks extends Par {
    static {
        y = 5;
    }
}

public class Check {
    public static void main(String args[]) {
        System.out.println(Checks.y); // here printing 4
    }
}

由于静态在所有子类之间共享,因此应该更新该值.

它背后的原因是什么？

我试图使用这样的静态块:

我有一个基类叫 Base.java

public class Base {

    static public int myVar;

}

派生类Derived.java:

public class Derived extends Base {

    static
    {
        Base.myVar = 10;
    }
}

我的main功能是这样的:

public static void main(String[] args)  {
    System.out.println(Derived.myVar);
    System.out.println(Base.myVar);
}

这打印输出0 0就像我预期的那样10 0.有人可以解释这种行为吗？另外,如果我希望我的派生类设置静态变量的值,我该如何实现呢？

什么是Scala相当于Java的静态块？

我有一个带有一些静态成员的类,我想运行一些代码来初始化它们(假设这段代码不能转换成简单的表达式).在Java中,我会这样做

class MyClass {
    static int myDatum;

    static {
        /* do some computation which sets myDatum */
    }
}

除非我弄错了,C++不允许这样的静态代码块,对吧？我应该做什么呢？

我想要解决以下两个选项:

1. 进程加载时(或加载此类的DLL时)会发生初始化.
2. 初始化在首次实例化类时发生.

对于第二种选择,我在考虑:

class StaticInitialized {
    static bool staticsInitialized = false;

    virtual void initializeStatics();

    StaticInitialized() {
        if (!staticsInitialized) {
            initializeStatics();
            staticsInitialized = true;
        }
    }
};

class MyClass : private StaticInitialized {
    static int myDatum;

    void initializeStatics() {
        /* computation which sets myDatum */
    }
};

但这是不可能的,因为C++(目前？)不允许初始化非const静态成员.但是,至少可以通过表达式将静态块的问题减少到静态初始化的问题......

我遇到了一个问题,我正在创建一个ThreadLocal并用新的ThreadLocal初始化它.问题是,我在概念上只是想要一个持久的列表,这个列表会延续线程的生命,但我不知道是否有办法在Java中初始化每个线程的东西.

例如,我想要的是:

ThreadLocal static {
  myThreadLocalVariable.set(new ArrayList<Whatever>());
}

这样它就可以为每个线程初始化它.我知道我可以这样做:

private static Whatever getMyVariable() {
  Whatever w = myThreadLocalVariable.get();
  if(w == null) {
    w = new ArrayList<Whatever>();
    myThreadLocalVariable.set(w);
  }
  return w; 
}

但是每次使用它时我都不需要检查它.我能在这做什么更好的事情吗？