静态方法是否接近纯方法？能否作为纯方法的合格替代方案？

Great observation! You’re right that static methods often align well with the definition of pure functions, but it’s not a one-to-one equivalence—let’s break this down clearly.

First, let’s nail down what a pure method is #

A pure method has two non-negotiable rules:

• It returns the same output every time given the same input (no hidden state affecting the result).
• It has no observable side effects: no modifying instance variables, static variables, global state, performing I/O (like logging, writing files), or changing anything outside the method’s scope.

Why static methods often fit the bill #

Your point about static methods being unable to access instance variables is spot-on. This removes a huge source of accidental side effects right out the gate. Most utility-style static methods are designed exactly for pure computation:

• Think of Math.pow() or String.join()—they take input values, compute a result, and return it without touching any external state.
• Since they don’t rely on instance state, it’s easier to reason about their behavior and test them (no need to set up an instance first).

But static methods aren’t always pure #

The key catch is that static methods can still violate pure method rules if they interact with mutable static state or perform side effects. Here are common examples:

1. Modifying or relying on static variables #

If a static method reads or writes a static class field, it’s no longer pure. For example:

public class StatsTracker {
    private static int totalCalls = 0;

    public static int trackAndReturn(int input) {
        totalCalls++; // Side effect: modifies static state
        return input * 2;
    }
}

Every call to trackAndReturn(5) will return 10, but it also changes the totalCalls value—this is an observable side effect, so it’s not pure. Even if you only read a mutable static variable, if that variable can be changed elsewhere, the method’s output can vary with the same input.

2. Performing I/O or external interactions #

Any static method that does things like logging to console, writing to a file, or calling an API has side effects. For example:

def log_and_return(value):
    print(f"Processing value: {value}") # Side effect: console output
    return value * 3

Even though it returns a consistent result for the same input, the print statement is an observable side effect, making it non-pure.

3. Relying on mutable external state #

If a static method uses values that change outside its control (like system time, a database, or a non-pure helper method), it’s not pure. For example:

function getTimestampedGreeting(name) {
    const now = new Date().toLocaleTimeString(); // Depends on current time
    return `Hello ${name}, it's ${now}!`;
}

Calling getTimestampedGreeting("Alice") will return different results at different times, even with the same input—violating the first rule of pure methods.

So, can static methods be a valid stand-in for pure methods? #

Absolutely—but only if they adhere strictly to the pure method rules. Static methods are a great way to implement pure logic because their design discourages reliance on instance state, but you have to be intentional about avoiding static state mutations and side effects.

It’s also worth noting that pure methods don’t have to be static! For example, instance methods on immutable classes (like String.substring() in Java) are pure too—they don’t modify the original string (since it’s immutable) and return a consistent result for the same input.

内容的提问来源于stack exchange，提问作者Mandroid