ExceptionInInitializerError in Java

java.lang.ExceptionInInitializerError

Signals that an unexpected exception has occurred in a static initializer. An ExceptionInInitializerError is thrown to indicate that an exception occurred during the evaluation of a static initializer or the initializer for a static variable.

Implemented Interfaces:

Serializable

Declaration

public class ExceptionInInitializerError extends LinkageError {

    @java.io.Serial
    private static final long serialVersionUID = 1521711792217232256L;

    public ExceptionInInitializerError() {
        initCause(null); // Disallow subsequent initCause
    }

    public ExceptionInInitializerError(Throwable thrown) {
        super(null, thrown); // Disallow subsequent initCause
    }

    public ExceptionInInitializerError(String s) {
        super(s, null); // Disallow subsequent initCause
    }

    public Throwable getException() {
        return super.getCause();
    }

    @java.io.Serial
    private static final ObjectStreamField[] serialPersistentFields = {
            new ObjectStreamField("exception", Throwable.class) };

    @java.io.Serial
    private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
        ObjectInputStream.GetField fields = s.readFields();
        Throwable exception = (Throwable) fields.get("exception", null);
        if (exception != null) {
            setCause(exception);
        }
    }

    @java.io.Serial
    private void writeObject(ObjectOutputStream out) throws IOException {
        ObjectOutputStream.PutField fields = out.putFields();
        fields.put("exception", super.getCause());
        out.writeFields();
    }

}

Methods

1. ExceptionInInitializerError()

java.lang.ExceptionInInitializerError.ExceptionInInitializerError()

Constructs an ExceptionInInitializerError with null as its detail message string and with no saved throwable object. A detail message is a String that describes this particular exception.

Approach

Java

public class ExceptionInInitializerError1 {
    public static void main(String[] args) {
        ExceptionInInitializerError exception = 
                         new ExceptionInInitializerError();

        System.out.println(exception);
    }
}

Output:

java.lang.ExceptionInInitializerError

2. ExceptionInInitializerError(String s)

java.lang.ExceptionInInitializerError.ExceptionInInitializerError(String s)

Constructs an ExceptionInInitializerError with the specified detailed message string. A detail message is a String that describes this particular exception. The detail message string is saved for later retrieval by the Throwable.getMessage() method. There is no saved throwable object.

Parameters: s the detailed message

Approach

Java

public class ExceptionInInitializerError2 {
    public static void main(String[] args) {

        String s = "HELLO";
        ExceptionInInitializerError exception = 
                     new ExceptionInInitializerError(s);

        System.out.println(exception);
    }
}

Output:

java.lang.ExceptionInInitializerError: HELLO

3. ExceptionInInitializerError(Throwable thrown)

java.lang.ExceptionInInitializerError.ExceptionInInitializerError(Throwable thrown)

Constructs a new ExceptionInInitializerError class by saving a reference to the Throwable object thrown for later retrieval by the getException() method. The detail message string is set to null.

Parameters: thrown The exception thrown

Approach

Java

public class ExceptionInInitializerError3 {
    public static void main(String[] args) {

        Throwable thrown = new NullPointerException();
        ExceptionInInitializerError exception =
                        new ExceptionInInitializerError(thrown);

        System.out.println(exception);
    }
}

Output:

java.lang.ExceptionInInitializerError

Some other Errors/Exceptions

AbstractMethodError: Thrown when an application tries to call an abstract method.

ArithmeticException: Thrown when an exceptional arithmetic condition has occurred.

ArrayIndexOutOfBoundsException: Thrown to indicate that an array has been accessed with an illegal index.

ArrayStoreException: Thrown to indicate that an attempt has been made to store the wrong type of object into an array of objects.

AssertionError: Thrown to indicate that an assertion has failed.

BootstrapMethodError: Thrown to indicate that an invoke dynamic instruction or a dynamic constant failed to resolve its bootstrap method and arguments, or invoke dynamic instruction the bootstrap method has failed to provide a call site with a target of the correct method type, or for a dynamic constant, the bootstrap method has failed to provide a constant value of the required type.

ClassCastException: Thrown to indicate that the code has attempted to cast an object to a subclass of which it is not an instance.

ClassCircularityError: Thrown when the Java Virtual Machine detects a circularity in the superclass hierarchy of a class is loaded.

ClassFormatError: Thrown when the Java Virtual Machine attempts to read a class file and determines that the file is malformed or otherwise cannot be interpreted as a class file.

ClassNotFoundException: Thrown when an application tries to load in a class through its string name using: The forName method in class Class. The findSystemClass method in class ClassLoader. The loadClass method in class ClassLoader.

CloneNotSupportedException: Thrown to indicate that the clone method in class Object has been called to clone an object, but the object's class does not implement the Cloneable interface.

Error: An Error is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch.

Exception: The class Exception and its subclasses are a form of Throwable that indicates conditions that a reasonable application might want to catch.

ExceptionInInitializerError: Signals that an unexpected exception has occurred in a static initializer.

IllegalAccessError: Thrown if an application attempts to access or modify a field, or to call a method that it does not have access to.

IllegalAccessException: An IllegalAccessException is thrown when an application tries to reflectively create an instance (other than an array), set or get a field, or invoke a method, but the currently executing method does not have access to the definition of the specified class, field, method or constructor.

IllegalArgumentException: Thrown to indicate that a method has been passed an illegal or inappropriate argument.

IllegalCallerException: Thrown to indicate that a method has been called by an inappropriate caller.

IllegalMonitorStateException: Thrown to indicate that a thread has attempted to wait on an object's monitor or to notify other threads waiting on an object monitor without owning the specified monitor.

IllegalStateException: Signals that a method has been invoked at an illegal or inappropriate time.

IllegalThreadStateException: Thrown to indicate that a thread is not in an appropriate state for the requested operation.

IncompatibleClassChangeError: Thrown when an incompatible class change has occurred to some class definition.

IndexOutOfBoundsException: Thrown to indicate that an index of some sort (such as to an array, to a string, or to a vector) is out of range.

InstantiationError: Thrown when an application tries to use the Java new construct to instantiate an abstract class or an interface.

InstantiationException: Thrown when an application tries to create an instance of a class using the newInstance method in class Class, but the specified class object cannot be instantiated.

InternalError: This is thrown to indicate some unexpected internal error has occurred in the Java Virtual Machine.

InterruptedException: Thrown when a thread is waiting, sleeping, or otherwise occupied, and the thread is interrupted, either before or during the activity.

LayerInstantiationException: Thrown when creating a module layer fails.

LinkageError: Subclasses of LinkageError indicate that a class has some dependency on another class; however, the latter class has incompatibly changed after the compilation of the former class.

NegativeArraySizeException: Thrown if an application tries to create an array with a negative size.

NoClassDefFoundError: Thrown if the Java Virtual Machine or a ClassLoader instance tries to load in the definition of a class (as part of a normal method call or as part of creating a new instance using the new expression)and no definition of the class could be found.

NoSuchFieldError: Thrown if an application tries to access or modify a specified field of an object, and that object no longer has that field.

NoSuchFieldException: Signals that the class doesn't have a field of a specified name.

NoSuchMethodError: Thrown if an application tries to call a specified method of a class (either static or instance), and that class no longer has a definition of that method.

NoSuchMethodException: Thrown when a particular method cannot be found.

NullPointerException: Thrown when an application attempts to use null in a case where an object is required.

NumberFormatException: Thrown to indicate that the application has attempted to convert a string to one of the numeric types, but that the string does not have the appropriate format.

OutOfMemoryError: Thrown when the Java Virtual Machine cannot allocate an object because it is out of memory, and no more memory could be made available by the garbage collector.

ReflectiveOperationException: Common superclass of exceptions thrown by reflective operations in core reflection.

RuntimeException: RuntimeException is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtual Machine.

SecurityException: Thrown by the security manager to indicate a security violation.

StackOverflowError: Thrown when a stack overflow occurs because an application recurses too deeply.

StringIndexOutOfBoundsException: Thrown by String methods to indicate that an index is either negative or greater than the size of the string.

TypeNotPresentException: Thrown when an application tries to access a type using a string representing the type's name, but no definition for the type with the specified name can be found.

UnknownError: Thrown when an unknown but serious exception has occurred in theJava Virtual Machine.

UnsatisfiedLinkError: Thrown if the Java Virtual Machine cannot find an appropriate native-language definition of a method declared native.

UnsupportedClassVersionError: Thrown when the Java Virtual Machine attempts to read a class file and determines that the major and minor version numbers in the file are not supported.

UnsupportedOperationException: Thrown to indicate that the requested operation is not supported.

VerifyError: Thrown when the "verifier" detects that a class file, though well-formed, contains some sort of internal inconsistency or security problem.

VirtualMachineError: This indicates that the Java Virtual Machine is broken or has run out of resources necessary for it to continue operating.