Class with single method -- best approach?

java

best-practices

object-oriented-design

utility-classes

byAnton Shumikhin·Oct 23, 2024

To create a single-method class, use a functional interface together with a lambda expression. Use the @FunctionalInterface annotation and implement the task with a lambda for both brevity and clarity:

// Here's your glorious function interface
@FunctionalInterface
public interface Task {
  void execute(); // The method performing magic
}

Task task = () -> System.out.println("Task completed. Now grabbing a coffee ☕️");
task.execute(); // And behold, it runs!

This method streamlines your code, removing unnecessary clutter, especially useful for brief, single-action sequences.

To determine whether you should use a static or an instance method inside a single-method class, remember that the context and practicality of the method matter more than anything else.

Cut to the chase: static vs. instance

Static methods: the handymen of Java

Static methods, which you can invoke without creating an instance of their class, are perfect as utility functions where state retention between calls isn't necessary, like:

Statelessness: Think of them as "one and done" actions.
Reusability: Use across various parts of the application.
Supplier's delight: No need to manage object's lifecycle.

Yet, they do fall short in certain areas:

Polymorphism: Static methods can't be overridden, leading to inflexibility.
Testing difficulty: Mocking static methods is often more complex, complicating test-driven development.

Instance methods: the chameleons of Java

Instance methods, defined and acting upon an object's state, offer:

Polymorphism: Easy to modify and extend.
Testing simplicity: These are straightforward to fake or substitute with test stubs.
High cohesion: Promote logically consistent and grouped functionalities within a class.

Their downsides do include:

Overhead costs: Unnecessary creation if the method isn't managing state.
Understanding challenge: More complex to reason about when incorrectly used for stateless functions.

When should you prefer static over instance methods? Here are some guidelines:

Utility Classes: Use static methods when making utility classes that focus on functional programming.
In-house logic: Lean on instance methods to manage state and abide by the principles of object-oriented design (OOD).
Long-term service: Choose instance methods for the code you anticipate will undergo changes or extensions.
Swift and stuff: Be cautious about object creation, particularly if your method doesn't require state between invocations.

Single-method class: Use case matters!

Single tasks made simple

For single tasks within your code, static methods are no-nonsense, straight-to-the-point tools. However, context is key:

Short-lived: Static if the procedure isn't used often.
Unrelated: Use instance methods to avoid bloating your class with unrelated static methods.
No juggling: If your static methods need several parameters, restructure it, for better design.

Gearing up for expansion

Today's single-method class might be tomorrow's multi-method class. Think about it:

Growth: If the class is likely to house more related operations or behaviours, then instance methods are best.
Integration: Opting for instance methods allows easier integration with frameworks such as Spring or Java EE.

explain-codes / Java / Class with single method -- best approach?

Linked

When to use static methods



What is the equivalent of Java static methods in Kotlin?



Difference between Static and final?



What is a good use case for static import of methods?



Static method in a generic class?

