A Guide on Static Methods in Java With Examples

A static method in Java is associated with the class itself rather than individual instances or objects of the class. It operates at the class level and can be accessed and invoked without creating an instance of the class.

The function main is an instant example of a static method of any class in Java. It is automatically called at the start of the program when no object of that class is instantiated.

Let’s look at the static methods in Java in more detail.

We’ll cover:

• Introduction

• Uses of static methods

  • Utility function
  • Helper method
  • Factory method

• Keep in mind

  • Instance members

  • Polymorphism

  • Memory matters

• Wrapping up and next steps

Introduction to Static Methods in Java#

Particularly, when a local variable or method parameter has the same name as an instance variable, this can help disambiguate between the local variable/parameter and the instance variable. Since static methods are not tied to specific instances, they do not have the this available to directly access the instance variables or invoke non-static (instance) methods. The keyword static in the method declaration indicates its association with the class, rather than with any particular object of that class. Let’s have a look at an example of a static method.

In the above example:

• Line 5: In the setMyVariable method, this.myVariable refers to the instance variable myVariable, while myVariable alone refers to the method parameter.

• Line 16: To call a static method, we use the class name followed by the method name, like MyClass.setStaticVariable(), without the need to create an object of the class. However, the method setMyVariable() can’t be called using the class name.

• Lines 17–18: There must be an instance (object), obj, of the class to invoke obj.setMyVariable(5). In this particular call to setMyVariable(), the keyword this refers to obj, which is the calling object of the method.

This distinction from instance methods allows the static methods to be accessed conveniently. Having no attachment to the calling object makes the static methods suitable for defining utility functions, helper methods, factory methods, and other class-level operations.

Uses of Static Methods#

This refers to a function that provides commonly used functionality or performs a specific task that is not tied to a specific object or instance. The examples are:

• To encapsulate a specific functionality or operation frequently needed in various contexts.

• To operate solely on the input parameters provided to them, independent of object state (making them stateless) to be called without the need to create an object.

• To perform mathematical calculations, string manipulation, file handling, and various data transformations.

In this example, the printArray(), defined on lines 2–7, is a utility method provided by the Util class. It’s a general-purpose method that prints the elements of an array. Utility methods like this can be reused across different parts of our applications. Qualifying it with the class or object name is mandatory when calling it from outside its class.

Helper Method#

This refers to a method that provides auxiliary or supportive functionality within a class. It is designed to assist other methods or operations by performing specific subtasks or providing common functionality in a modular and reusable manner. Helper methods enhance the overall structure of a program and improve its maintainability by encapsulating common functionality into reusable blocks of code. The examples are:

• To validate data or the overall state of the system before changing the instance-level state to avoid inconsistency or anomaly.

• To simplify complex operations by breaking them into smaller, more manageable steps, like recursion (using the parameters).

• To promote code modularity and maintainability by providing a centralized location for commonly used functionality.

In this example, calculateSquare(), defined on lines 2–4, is a helper method that computes the square of a number. It assists the main() method by calculating and returning the square of an integer parameter.

The calculateSquare() method can be called with or without using the class name from main() of the same class. Similarly, it can be called with or without using the object name this from the same class’s non-static method fun().

Factory Method#

The factory method is a design pattern. It outlines a procedure for generating objects of a class or subclasses. It is especially valuable when we want to encapsulate complex object creation logic. For example, when we want to restrict the object instantiation to a specific number like Singleton.

The Singleton pattern ensures that a class has only one instance and provides a global access point to that instance. This is typically achieved by controlling the instantiation process through static methods and private constructors.

When combining these patterns, we might have a factory method that returns a singleton instance of a specific class. The following is a simple example:

In this example, the Singleton class directly manages the creation of the singleton instance through the getInstance() method.

• Line 2: A static attribute object is declared to keep hold of the instance of the class to be shared by all its users.

• Lines 4–6: An empty constructor is defined as private to control the instantiation.

• Lines 8–13: The getInstance() method is defined to return the previously or newly created object.

  • Line 9: The existence of the first instance is checked through the current value of obj.
  • Line 10: The object is created and stored to the static data member object for returning to its users.
  • Line 12: The instance stored in object is returned to the getInstance() caller.

• Lines 15–17: A non-static method showMessage() is defined to demonstrate the successful instantiation. The instance can’t be created here using the keyword new due to the constructor being private.

• Lines 19–22: The main() method is defined as static so that it is used as the program’s entry point before the class instantiation.

  • Line 20: The class instance is obtained through a call to getInstance() and stored in the variable myObject. Using the class name for calling the method is not mandatory here because main() is also part of the same class.
  • Line 21: The non-static method of the class is called through myObject because it can’t be called without the object from a static method.

When the getInstance() method is first called, it creates the instance if it doesn’t already exist. Subsequent calls to getInstance() return the existing instance.

The getInstance() method acts as a factory method responsible for creating and providing access to the single instance of the class. It encapsulates the logic for creating and maintaining the instance.

The concept of encapsulating the instantiation process and providing controlled access to instances aligns with the essence of a factory method.

Keep In Mind#

Instance Members#

Non-static members that are termed instance members are not directly accessible from static members. They are required to be qualified through an object. The static methods can be called without the object. The keyword this is also not accessible from the static methods so attempting to qualify an instance member with this will fail in those methods.

Polymorphism#

Polymorphism is a powerful feature of the object-oriented programming (OOP) paradigm. It provides the facility of calling the correct version of the method depending on the instance held by the base reference. It means we can call an overridden version of a base class method in its derived class using a derived instance through a base reference.

The static methods are class-level operations therefore they cannot be overridden. It’s not a weakness of Java; it’s the technically correct implementation. The static methods do not carry an implicit reference to the calling object (through this) therefore they cannot implicitly trace the type of calling object.

Memory Matters#

Static members are class-level features. They are provided as shared facilities for all instances of the class. Their construction and destruction are not bound to the life of any object. They are allocated in the memory at the start of the execution of the program or at the time of loading of the class. They are not garbage collected; therefore, they stay in the memory till the end of the program. We need to be more cautious about memory leaks due to the same reason.

Wrapping up and Next Steps#

A static method can be accessed using the class name (without instantiating any object). Here are the pros and cons of static methods in Java.

• The static method can be called from outside the class using the class or object name. However, using these qualifiers is optional when calling them from the methods of the same class.

• The static methods do not have the this keyword inside their definition because no object is tied to them.

• It is mandatory to use the object name when accessing the non-static methods or attributes from the static methods.

• The static method is a class-level operation; therefore, it can’t be overridden.

• The static members (including the data members) are created when loading the class into the memory and are not deleted from the memory like instance data members.

To get started with learning these concepts and more, check out Educative’s Java for Programmers and Zero to Hero in Java paths.

Continue learning about the subject#

• Grokking Coding Interview Patterns
• A Complete Guide to Java Programming
• Software Design Patterns: Best Practices for Software Developers