Getting the class name from a static method in Java

java

class-name

static-method

java-versions

byAnton Shumikhin·Dec 23, 2024

Using Thread.currentThread().getStackTrace() provides a workaround to retrieve the class name from within a static method:

public static String getClassName() {
    // A fact, not a joke: The "2" isn't a tribute to the "Matrix Reloaded" movie.
    // The 2nd element is usually your caller. Adjust accordingly.
    return Thread.currentThread().getStackTrace()[2].getClassName();
}

The magic index 2 corresponds to your static method's caller in the call stack. Keep in mind, the exact index may vary based on context.

Methods across Java versions

Java 7 and later: `MethodHandles.lookup()`

Java 7 introduced an elegant way to get class names in a static context:

public static String getClassName() {
    // No nonsense. Movie references do not apply here.
    return MethodHandles.lookup().lookupClass().getName();
}

Pre-Java 7: `new Object() trick`

Are you dealing with code fossils - application still running on versions before Java 7? The following workaround has your back:

public static String getClassName() {
    // Strictly not for modern families. Suitable for Java versions Jurassic and older.
    return new Object(){}.getClass().getEnclosingClass().getName();
}

This involves creating an anonymous inner class that holds a reference to its enclosing class.

Expert's caution

Avoid heavy use of Thread.currentThread().getStackTrace(), as it might cause performance issues. Devs sticking with proven practices prefer MethodHandles.lookup().lookupClass().

Upgrade your error handling and logging

Class names pimp your error messages and exceptions for better understanding. They can also power up a shared logger or an error handling unit:

public static void logError(Exception e) {
    Logger.getLogger(MyClass.class.getName()).log(Level.SEVERE, "Houston, we have a problem in " + MyClass.class.getSimpleName(), e);
}

SecurityManager: A peep-hole to the call stack

If thrill excites you, how about using SecurityManager to sneak a peek into the call stack?

public static String getClassName() {
    // This trick's sneakier than James Bond. Ensure SecurityManager's at your service.
    return System.getSecurityManager().getClassContext()[1].getName();
}

Remember, it depends on the active SecurityManager, a service that might be missing in some secure environments.

Sauntering in Kotlin's woods

Kotlin also employs a similar approach with a garnish of logging factories. A Java dev peeking into Kotlin land might find this intriguing:

companion object {
    // Kotlin's way of saying "Hello, world!"
    private val logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass())
}