Calling Non-Static Method In Static Method In Java

java

object-oriented-principles

static-methods

non-static-methods

byNikita Barsukov·Jan 31, 2025

To invoke a non-static method within a static context, you need to first create an instance of the class and then call the method on the instance. Observe the following no-nonsense example:

class Example {
    void nonStaticMethod() { /* Do something cool */ }

    static void staticMethod() {
        new Example().nonStaticMethod(); // Pulling a rabbit out of our static hat
    }
}

You can directly call the method after instantiating with new Example().nonStaticMethod(). Pretty straightforward, isn't it?

But wait, we've got more interesting stuff. Shall we dive a bit deeper?

When instance translates to Existence!

Not Just Static, be Dynamic

Keep your methods non-static if they're 'special' in any way. The dynamic nature of an object in Java is bound to its behaviors.

From Stranger.. to Neighbor!

Sometimes, you need to call a method from a class lurking in a completely different package. This is where import statements and the power of creating an instance swoops in to let you use those alien non-static methods.

Instance States - Handle with Care!

Remember, every instance holds its own unique state. If your non-static method tweaks an object's state, distinct instances might lead to distinct consequences.

Context Matters!

Static ≠ Convenience

Don't transform non-static methods into static ones just for an easy call. Both have different roles to play:

Static methods work on a class-level (they're for everyone).
Non-static methods are thoughtful (they operate on instance states).

Design for Future

In your class designs sticking the static logic and non-static logic in two different rooms. Based on necessity, use the elevator (Singleton or Service Locators pattern) to call the non-static methods.

Error-Proof your Non-static Methods

Ensure your static method is well-equipped to handle any exceptions thrown by non-static methods.

class ResourceUser {
    void riskyOperation() throws IOException { /* Walking the tightrope */ }
}

class Application {
    static void safeStaticMethod() {
        ResourceUser user = new ResourceUser();
        try {
            user.riskyOperation(); // Trying to balance
        } catch (IOException e) {
            // Handle the fall
        }
    }
}

Object-Oriented Principles – Keep'em Close!

Object-oriented principles are not just a bunch of fancy words. Understand and practice them. They help you make informed decisions about adopting static and non-static methods, ensuring reusability, scalability, and a tidy speration of concerns.