why return and throw keywords are not allowed in static block

Question

class TestCase{

  static{

    System.out.println("hello");

    return;

  }
  public static void main(String[] args){

    System.out.println("main");

  }

}

Answer 1

A static block is meant to be used for initialization of static variables, there should be no need to call return or throw an Exception within one.

If you need to return or throw an Exception, then I suggest utilizing what the Java™ Tutorial for a Static Initialization Block says to do and assign a method instead:

class Whatever {
    public static varType myVar = initializeClassVariable();

    private static varType initializeClassVariable() {
        // initialization code goes here
    }
}

Taken from https://docs.oracle.com/javase/tutorial/java/javaOO/initial.html

Answer 2

A return is not allowed because a static block is not strictly speaking a method. There is no "caller" to return to, and certainly nothing to return a value to. Besides, it is always possible to achieve the local flow control effect of a return-with-no-expression by restructuring the code a little bit.

(In your example, the return is redundant anyway ... from a local flow control perspective.)

In short, return is not allowed because it doesn't make sense. (Just like you can't use continue in code that isn't within a loop statement.)

---

Exceptions that propagate out of static blocks are problematic. Basically, there is no way for application code to catch and deal with them.

• The whole point of the checked / unchecked distinction is to ensure that certain exceptions cannot be ignored. Therefore the Java language treats a static block propagating checked exception as a compilation error.

• On the other hand, an unchecked exception is allowed to be thrown in a static block (and not caught). This leads to an ExceptionInInitializerError, and leaves the class that you were trying to initialize in a "dead" state. Typically the application cannot recover from this.

  Why allow this? Given the myriad ways that an unchecked exception can arise, it would be impractical for the Java language to insist that they are dealt with inside the static initializer block. Besides, an unexpected + unchecked exception is a really an application bug. The simplest / safest way to deal with a bug is for the application to die ... leaving evidence for a programmer to diagnose and fix the bug.

Answer 3

This question also applies to instance initializers as well as static initializers.

The return statement could be allowed, and it would be as useful as return in a void method. However, I think the biggest problem is the ambiguity in presence of multiple initializers:

static{  // 1
    ...
    ...return;
    ...
}
static{  // 2
    ...
}

if return is executed, does it just terminate block 1, and continue to block 2, or does it terminate all static initilization code?

For the question of throw, see Why is it not allowed to throw an exception in a Java instance initialization block?

My understanding is that, if a static/instance initializer unconditionally throws an exception, the class/constructor will always fail, rendering it pretty much useless. Therefore Java forbids it.

Workarounds:

return can be simulated by break from a labeled block:

static
{
    STATIC:
    {
        break STATIC;
    }
}

Unconditional throw can be achieved by if(true)

static
{
    if(true) throw new Error();
}

(Java specifically pretends to not know that the statement is definitely executed)

Answer 4

Because they can't be declared to either return a value or throw an exception. They are essentially anonymous static void methods that don't throw checked exceptions.