1. Overview
When we work with Java, we often run into problems that demand a deeper understanding of the language’s intricacies. One common puzzle is the error message: “Non-static method … cannot be referenced from a static context.” This error may seem daunting to beginners and can even confuse experienced programmers.
In this tutorial, we’ll delve into the reasons behind this error and explore ways to resolve it.
2. Introduction to the Problem
As usual, let’s understand the problem quickly through an example. Let’s say we have the ToolBox class:
class ToolBox {
private String concat(String str1, String str2) {
return str1 + str2;
}
static String joinTwoStrings(String str1, String str2) {
return concat(str1, str2); //<-- compilation error
}
}
The ToolBox class has the concat() method. We didn’t want everybody to call it, so we declared it a private method. Also, we have a static method joinTwoStrings(), which invokes the concat() method internally.
However, if we compile it, a compilation error occurs:
java: non-static method concat(java.lang.String,java.lang.String) cannot be referenced from a static context
Next, let’s understand what this error message means and see how to solve it.
3. What Does the Error Mean?
Before we tackle the non-static method issue, let’s understand the concept of a static context in Java.
In Java, the keyword “static” is used to declare elements that belong to the class rather than instances. Static members are shared among all instances of a class and can be accessed without creating an object of the class.
However, on the other hand, non-static methods are associated with instances of a class and cannot be invoked without creating an object. They can rely on the specific state of an object, and their behavior may vary depending on the values of instance variables.
The compilation error “Non-static method … cannot be referenced from a static context” occurs when an attempt is made to call a non-static method from a static context. This static context could be a static method, a static block, or the main() method, which is always static.
Now that we understand why the problem happens, let’s see how to fix it.
4. Resolving the Problem
We’ve learned that non-static members cannot be invoked without creating an instance. Then, depending on the requirement, we have a couple of ways to fix the problem.
Next, let’s take a closer look at them.
4.1. Calling Static Method From a Static Context
The first solution is turning the instance method into a static method. If we’ve done that transition, there won’t be any problem if we call it from a static context:
class ToolBox {
private static String concatStatic(String str1, String str2) {
return str1 + str2;
}
static String joinTwoStrings(String str1, String str2) {
return concatStatic(str1, str2);
}
}
As we can see in the code above, to make it easier to spot the changes we made, we used the new method name concatStatic. Further, we made it a static method by adding the static keyword.
Now, if we call the static joinTwoStrings() method, we get the expected result:
assertEquals("ab", ToolBox.joinTwoStrings("a", "b"));
4.2. Creating an Instance and Calling the Instance Method
Sometimes, the requirement doesn’t allow us to change the instance method to a static one. In this case, we can refactor the static method, first creating an instance and then calling the instance method:
class ToolBox {
private String concat(String str1, String str2) {
return str1 + str2;
}
static String creatingInstanceJoinTwoStrings(String str1, String str2) {
ToolBox toolBox = new ToolBox();
return toolBox.concat(str1, str2);
}
}
Now, if we call the static creatingInstanceJoinTwoStrings() method, it works properly:
assertEquals("ab", ToolBox.creatingInstanceJoinTwoStrings("a", "b"));
Alternatively, we can consider whether the creatingInstanceJoinTwoStrings() method in this class must be static. If not, we can also convert the static method into a regular instance method:
class ToolBox {
private String concat(String str1, String str2) {
return str1 + str2;
}
String instanceJoinTwoStrings(String str1, String str2) {
return concat(str1, str2);
}
}
With this fix, the instanceJoinTwoStrings() method is no longer static. So, it can invoke the private concrete() instance method directly.
Of course, when we utilize instanceJoinTwoStrings(), we must first create a ToolBox object:
ToolBox toolBox = new ToolBox();
assertEquals("ab", toolBox.instanceJoinTwoStrings("a", "b"));
5. Can a Static Method Be Called by an Instance?
We’ve learned we cannot reference non-static members from a static context. Some might ask, can we call a static method in an instance method?
Next, let’s give it a test:
class ToolBox {
private static String concatStatic(String str1, String str2) {
return str1 + str2;
}
String instanceCallStaticJoinTwoStrings(String str1, String str2) {
return concatStatic(str1, str2);
}
}
As we can see in the code above, the instance method instanceCallStaticJoinTwoStrings() calls the private static method concatStatic().
The code compiles. Further, if we test it, it works properly:
ToolBox toolBox = new ToolBox();
assertEquals("ab", toolBox.instanceCallStaticJoinTwoStrings("a", "b"));
So, the answer to the question is yes.
In Java, calling a static method from an instance method is allowed. This is because static members aren’t tied to a specific instance. Instead, they’re associated with the class itself and can be invoked using the class name. In our code, we called concatStatic(str1, str2) without the class name “ToolBox.concatStatic(str1, str2)” since we’re already in the ToolBox class.
6. Conclusion
In this article, we explored the compilation error “Non-static method cannot be referenced from a static context,” delving into its causes and examining various resolutions to address and fix this issue.
As always, the complete source code for the examples is available over on GitHub.
