Based on my understanding of the Java language, static variables can be initialized in static initialization block
.
However, when I try to implement this in practice (static
variables that are final
too), I get the error shown in the screenshot below:
Instance variables are initialized using initialization blocks. However, the static initialization blocks can only initialize the static instance variables. These blocks are only executed once when the class is loaded.
A final variable can only be initialized once, either via an initializer or an assignment statement. There are three ways to initialize a final variable: You can initialize a final variable when it is declared. This approach is the most common.
The only way to initialize static final variables other than the declaration statement is Static block. A static block is a block of code with a static keyword. In general, these are used to initialize the static members. JVM executes static blocks before the main method at the time of class loading.
If you declare a static variable in a class, if you haven't initialized it, just like with instance variables compiler initializes these with default values in the default constructor. Yes, you can also initialize these values using the constructor.
Yes of course: static final
variables can be initialized in a static block but.... you have implicit GOTOs in that example (try/catch
is essentially a 'GOTO catch if something bad happens').
If an exception is thrown your final
variables will not be initialized.
Note that the use of static constructs goes against Object-Oriented dogma. It may complicate your testing and make debugging more difficult.
You can do this but you need to exit the static block by throwing an exception - you can rethrow the exception that was caught or a new one. Generally this exception must be a RuntimeException
. You really should not catch a generic Exception
but more specific exception(s) that might be thrown from within your try
block. Finally, if a static initializer throws an exception then it will render the class unusable during that specific run because the JVM will only attempt to initialize your class once. Subsequent attempts to use this class will result in another exception, such as NoClassDefFoundError
.
So, to work, your initializer should read something like this:
static { try { ... } catch (Exception e) { e.PrintStackTrace(); throw new InitializationFailedException("Could not init class.", e); } }
Assuming that InitializationFailedException
is a custom RuntimeException
, but you could use an existing one.
public class MyClass
{
private static final SomeClass myVar;
static
{
Object obj = null; // You could use SomeClass, but I like Object so you can reuse it
try
{
obj = new SomeClass(...);
}
catch(WhateverException err)
{
// Possibly nested try-catches here if the first exception is recoverable...
// Print an error, log the error, do something with the error
throw new ExceptionInInitializerError(err);
}
finally
{
myVar = (SomeClass) obj;
}
}
}
Assuming no where upstream is in a position to catch either an ExceptionInInitializationError or a general Exception then the program should not ever try to use myVar. If however those are caught and the program doesn't end, then you need to code to watch for and handle myVar being null (or be happy with NullPointerExceptions
coming out all over).
I'm not sure there is a good way to handle this.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With