IllegalAccessError in Java

1. Overview

In this quick tutorial, we'll discuss the java.lang.IllegalAccessError.

We'll examine some examples of when it is thrown and how to avoid it.

2. Introduction to IllegalAccessError

An IllegalAccessError is thrown when an application attempts to access a field or invoke a method that is inaccessible.

The compiler catches such illegal invocations, but we may still bump into an IllegalAccessError at runtime.

First, let's observe the class hierarchy of IllegalAccessError:

java.lang.Object
  |_java.lang.Throwable
    |_java.lang.Error
      |_java.lang.LinkageError
        |_java.lang.IncompatibleClassChangeError
          |_java.lang.IllegalAccessError

Its parent class is IncompatibleClassChangeError. Hence, the cause of this error is an incompatible change in one or more class definitions in the application.

Simply put, the version of the class at runtime is different from the one it was compiled against.

3. How May This Error Occur?

Let's understand this with a simple program:

public class Class1 {
    public void bar() {
        System.out.println("SUCCESS");
    }
}
public class Class2 {
    public void foo() {
        Class1 c1 = new Class1();
        c1.bar();
    }
}

At runtime, the above code invokes the method bar() in Class1. So far, so good.

Now, let's update the access modifier of bar() to private and independently compile it.

Next, replace the previous definition of Class1 (the .class file) with the newly compiled version and re-run the program:

java.lang.IllegalAccessError: 
  class Class2 tried to access private method Class1.bar()

The above exception is self-explanatory. The method bar() is now private in Class1. Clearly, it's illegal to access.

4. IllegalAccessError in Action

4.1. Library Updates

Consider an application that uses a library at compile time, and the same is also available in classpath during runtime.

The library owner updates a publicly available method to private, rebuilds it, but forgets to update other parties of this change.

Furthermore, while executing, when the application invokes this method (assuming public access), it runs into an IllegalAccessError.

4.2 Interface Default Methods

Misuse of default methods in Interfaces is another cause of this error.

Consider the following interface and class definitions:

interface Baeldung {
    public default void foobar() {
        System.out.println("This is a default method.");
    }
}
class Super {
    private void foobar() {
        System.out.println("Super class method foobar");
    }
}

Also, let's extend Super and implement Baeldung:

class MySubClass extends Super implements Baeldung {}

Finally, let's invoke foobar() by instantiating MySubClass:

new MySubClass().foobar();

The method foobar() is private in Super and default in Baeldung. Hence, it is accessible in the hierarchy of MySubClass.

Therefore, the compiler doesn't complain, but at runtime, we get an error:

java.lang.IllegalAccessError:
  class IllegalAccessErrorExample tried to access private method 'void Super.foobar()'

During execution, a super-class method declaration always takes priority over an interface default method.

Technically, foobar from Super should have been called, but it's private. Undoubtedly, an IllegalAccessError will be thrown.

5. How to Avoid it?

Precisely, if we run into an IllegalAccessError, we should primarily look for changes in the class definitions with respect to access modifiers.

Secondly, we should validate interface default methods overridden with a private access modifier.

Making the class-level method public will do the trick.

6. Conclusion

To conclude, the compiler will resolve most of the illegal method invocations. If we still come across an IllegalAccesError, we need to look into class definition changes.

The source code of the examples is available over on GitHub.