Class Methods vs Instance Methods in Java
Last updated: January 8, 2024
Mocking is an essential part of unit testing, and the Mockito library makes it easy to write clean and intuitive unit tests for your Java code.
Get started with mocking and improve your application tests using our Mockito guide:
Handling concurrency in an application can be a tricky process with many potential pitfalls. A solid grasp of the fundamentals will go a long way to help minimize these issues.
Get started with understanding multi-threaded applications with our Java Concurrency guide:
Spring 5 added support for reactive programming with the Spring WebFlux module, which has been improved upon ever since. Get started with the Reactor project basics and reactive programming in Spring Boot:
Since its introduction in Java 8, the Stream API has become a staple of Java development. The basic operations like iterating, filtering, mapping sequences of elements are deceptively simple to use.
But these can also be overused and fall into some common pitfalls.
To get a better understanding on how Streams work and how to combine them with other language features, check out our guide to Java Streams:
Explore Spring Boot 3 and Spring 6 in-depth through building a full REST API with the framework:
Yes, Spring Security can be complex, from the more advanced functionality within the Core to the deep OAuth support in the framework.
I built the security material as two full courses - Core and OAuth, to get practical with these more complex scenarios. We explore when and how to use each feature and code through it on the backing project.
You can explore the course here:
Spring Data JPA is a great way to handle the complexity of JPA with the powerful simplicity of Spring Boot.
Get started with Spring Data JPA through the guided reference course:
Refactor Java code safely — and automatically — with OpenRewrite.
Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.
Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.
Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.
Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.
Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.
In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:
1. Introduction
In this tutorial, we’ll explore the difference between class methods and instance methods in Java.
In object-oriented programming, a method is the equivalent of a function. This means it’s an action that an object can perform. We use instance methods when they operate on member variables and use static methods when no instance of the class is required for the method to execute. Let’s understand this in more detail next.
2. Instance vs Static Methods
Like in most object-oriented languages, we create class definitions in Java and instantiate them as objects.
These objects have attributes associated with them (member variables) and methods that usually refer to these member variables. When methods reference non-static member variables, we must define them as instance methods.
We sometimes define a method that doesn’t reference member variables or only references static variables. When we do this, we can make the method a static method. This means that we don’t need an instance of the class to invoke the method.
There are differences in behavior between class and instance methods, so let’s get started with an example.
To define a method as static we simply need to use the static keyword. Here’s an example of a class that contains both a static method and an instance method:
public class MyClass {
public static boolean isAllLowerCaseStatic(String word) {
return word.toLowerCase().equals(word);
}
public boolean isAllLowerCaseInstance(String word) {
return word.toLowerCase().equals(word);
}
}There’s an important difference to remember when we invoke these methods. To use an instance method, we must first instantiate the class that holds the method definition:
MyClass obj = new MyClass();
obj.isAllLowerCaseInstance("test");In the case of invoking static methods, we can reference the class directly:
MyClass.isAllLowerCaseStatic("test");Our isAllLowerCaseStatic() method is a good usage of a static method since it doesn’t reference any member variables belonging to the object instance.
It’s important to remember that while static methods may seem like a good choice, they can be difficult to unit test since there’s no object to mock.
Static methods can introduce concurrency issues if the method operates on a static member variable. In this case, we can use the synchronized keyword in the method definition.
3. Conclusion
In this article, we learned the difference between class or static methods and instance methods in Java. We discussed how to define static and instance methods and how to invoke each of them.
We should remember that the key difference is that we must invoke an instance method through an instantiated object, while we can access a static method directly through the class.
