The field y is not declared by class Checks. Reading static fields doesn’t trigger initialization of the referenced class (Checks), unless that class is the one in which the field is declared (see JLS quote below). In this example, even if y is accessed through Checks, that will only trigger the initialization of Par because … Read more
You just override the initialValue() method: private static ThreadLocal<List<String>> myThreadLocal = new ThreadLocal<List<String>>() { @Override public List<String> initialValue() { return new ArrayList<String>(); } };
As I understand. You don’t call any Derived properties (myVar belongs to Base, not to Derived). And java is not running static block from Derived. If you add some static field to Derived and access it, then java executes all static blocks. class Base { static public int myVar; } class Derived extends Base { … Read more
You can have static blocks in C++ as well – outside classes. It turns out we can implement a Java-style static block, albeit outside of a class rather than inside it, i.e. at translation unit scope. The implementation is a bit ugly under the hood, but when used it’s quite elegant! Downloadable version There’s now … Read more
You need to know that enum values are static fields which hold instances of that enum type, and initialization order of static fields depends on their position. See this example class SomeClass{ public SomeClass() { System.out.println(“creating SomeClass object”); } } class StaticTest{ static{ System.out.println(“static block 1”); } static SomeClass sc = new SomeClass(); static{ System.out.println(“static … Read more
PowerMock is another mock framework that extends EasyMock and Mockito. With PowerMock you can easily remove unwanted behavior from a class, for example a static initializer. In your example you simply add the following annotations to your JUnit test case: @RunWith(PowerMockRunner.class) @SuppressStaticInitializationFor(“some.package.ClassWithStaticInit”) PowerMock does not use a Java agent and therefore does not require modification … Read more
Yes, you are right. Static initialization blocks are run when the JVM (class loader – to be specific) loads StaticClass (which occurs the first time it is referenced in code). You could force this method to be invoked by explicitly calling StaticClass.init() which is preferable to relying on the JVM. You could also try using … Read more
They’re for two very different purposes: The static initializer block will be called on loading of the class, and will have no access to instance variables or methods. As per @Prahalad Deshpande’s comment, it is often used to create static variables. The non-static initializer block on the other hand is created on object construction only, … Read more
I learn visually, so here’s a visual representation of order, as a SSCCE: public class Example { static { step(1); } public static int step_2 = step(2); public int step_8 = step(8); public Example(int unused) { super(); step(10); } { step(9); } // Just for demonstration purposes: public static int step(int step) { System.out.println(“Step ” … Read more
The non-static block: { // Do Something… } Gets called every time an instance of the class is constructed. The static block only gets called once, when the class itself is initialized, no matter how many objects of that type you create. Example: public class Test { static{ System.out.println(“Static”); } { System.out.println(“Non-static block”); } public … Read more