Java中是否存在与C++ Static修饰符功能完全相同的修饰符？

当然有办法实现！Java里确实没有直接对应C++函数内static局部变量的语法——你不能在Java的方法内部声明static变量，但我们可以用几种简洁的方式达到完全相同的效果：让变量只初始化一次，每次调用函数时保留上次调用后的取值。

下面针对你给出的C++示例，提供几种等价的Java实现方案：

方案1：使用类的静态成员变量（最直接的替代） #

这是最常用的方式，把需要持久化的变量声明为类的静态成员，然后在目标方法中操作它。这种方式的行为和C++的局部static变量完全一致：

public class CounterDemo {
    // 用类静态成员模拟C++函数内的static变量，仅初始化一次
    private static int count = 0;

    public static void counter() {
        System.out.print(count++ + " ");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            counter();
        }
    }
}

运行后输出：0 1 2 3 4，和你的C++示例结果完全匹配。

方案2：封装状态的函数对象（更安全的封装） #

如果不想让这个状态变量暴露给类的其他方法，可以用一个封装了状态的内部对象来实现，比如利用Supplier接口：

import java.util.function.Supplier;

public class CounterDemo {
    // 把状态变量封装在Supplier实例中，仅内部可访问
    private static final Supplier<Integer> counterState = new Supplier<>() {
        private int count = 0;

        @Override
        public Integer get() {
            return count++;
        }
    };

    public static void counter() {
        System.out.print(counterState.get() + " ");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            counter();
        }
    }
}

这种方式把count变量完全封装起来，只有counter()方法能通过get()访问它，避免了类的其他方法意外修改这个状态，比方案1更符合封装原则。

方案3：线程安全的实现（适合多线程场景） #

如果你的counter()方法可能被多个线程调用，C的局部static变量在C11之前存在线程安全问题，而Java可以用AtomicInteger轻松实现线程安全的版本：

import java.util.concurrent.atomic.AtomicInteger;

public class CounterDemo {
    private static final AtomicInteger count = new AtomicInteger(0);

    public static void counter() {
        // getAndIncrement()原子性地获取当前值并自增
        System.out.print(count.getAndIncrement() + " ");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            counter();
        }
    }
}

这个版本不仅能实现你要的功能，还天然支持多线程环境，不用担心并发修改的问题。

补充说明 #

Java之所以没有提供局部static变量，是因为这种特性容易导致方法的状态变得不透明，甚至引发意外的内存泄漏（比如变量持有外部类引用时），违背了面向对象的封装和设计原则。所以上面的几种方案都是更符合Java设计思想的替代方式。

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