Static Method

Introduction

A Static Method is a function defined within a class but is not bound to an instance of that class. Instead, it is associated with the class itself, and can be called using the class name directly, without creating any objects.

Static methods are commonly used for:

• Performing utility operations
• Creating factory methods
• Encapsulating functionality that doesn’t rely on instance state

They are widely supported in object-oriented programming languages such as Java, C#, Python, C++, and TypeScript.

Key Characteristics

Syntax Across Languages

Java

public class MathUtil {
    public static int square(int x) {
        return x * x;
    }
}

// Call without creating an object
int result = MathUtil.square(5);  // 25

C#

class Converter {
    public static double ToCelsius(double fahrenheit) {
        return (fahrenheit - 32) * 5 / 9;
    }
}

double temp = Converter.ToCelsius(98.6);  // 37.0

Python

Python uses a decorator:

class Utils:
    @staticmethod
    def greet(name):
        return f"Hello, {name}!"

print(Utils.greet("Alice"))

Unlike class methods (@classmethod), static methods in Python don’t receive self or cls as their first argument.

When to Use Static Methods

Instance Method vs Static Method

Factory Method Example (Java)

public class Person {
    String name;

    private Person(String name) {
        this.name = name;
    }

    public static Person create(String name) {
        return new Person(name);
    }
}

Usage:

Person p = Person.create("Alice");

Static Method in Inheritance

Java

Static methods are not polymorphic—they do not override in child classes.

class Parent {
    static void greet() { System.out.println("Hello from parent"); }
}

class Child extends Parent {
    static void greet() { System.out.println("Hello from child"); }
}

Parent p = new Child();
p.greet();  // Outputs: Hello from parent

C#

Same behavior: static methods are resolved at compile-time, not runtime.

Static Method in Python

Python allows static methods in both classic and modern classes:

class Math:
    @staticmethod
    def add(x, y):
        return x + y

Cannot access self or cls:

class Example:
    static_var = 42

    @staticmethod
    def show():
        print(Example.static_var)

Can Static Methods Access Class Variables?

Only if those variables are also static or class-level.

Java

public class Config {
    private static int version = 2;

    public static void showVersion() {
        System.out.println(version);  // ✅ Allowed
    }
}

Python

class App:
    version = "1.0"

    @staticmethod
    def info():
        print(App.version)

Thread Safety of Static Methods

Static methods can be thread-safe if they:

• Don’t mutate shared state
• Only operate on local variables or thread-local storage
• Use synchronization when accessing shared resources

Caution: if a static method modifies static variables, thread safety must be enforced using locks or concurrent structures.

Static Method vs Global Function

Static Method vs Class Method (Python)

class Sample:
    @staticmethod
    def static_method():
        print("Static")

    @classmethod
    def class_method(cls):
        print(f"Class: {cls}")

Pros and Cons

✅ Advantages

• No need to create an object
• Useful for stateless, reusable functionality
• Helps encapsulate related utility logic
• Improves performance (no instance dispatch)
• Can be used in static initialization

❌ Disadvantages

• No access to instance members
• Harder to override in polymorphic systems
• May encourage procedural style in OO code
• Can lead to poor encapsulation if misused

Design Patterns Using Static Methods

Static Method in TypeScript

class MathUtil {
    static square(n: number): number {
        return n * n;
    }
}

console.log(MathUtil.square(4)); // 16

Static methods can be called without creating an object, and help organize code better than loose functions.

Real-World Examples

Summary

Related Keywords

• Class Method
• Factory Method
• Global Function
• Instance Method
• Namespacing
• Object-Oriented Programming
• Procedural Programming
• Static Variable
• Utility Class
• Thread Safety