C++ 和 Java 中 static 关键字的比较

1. C++ 中的 static

在 C++ 中，static 关键字会与函数或变量一起使用。

1.1 静态局部变量

在函数内部声明的变量，如果使用 static 关键字，则它就成为 静态局部变量。它的生命周期与程序一致，但它的作用域只在函数内部。

#include <iostream>

void myFunc() {
    static int count = 0;
    count++;
    std::cout << "count: " << count << std::endl;
}

int main() {
    myFunc(); // count: 1
    myFunc(); // count: 2
    myFunc(); // count: 3
    return 0;
}

在以上代码中， count 的生命周期与整个程序一致，但其作用域只在 myFunc 函数内部。每次函数调用结束后，count 的值会被保留下来，最终输出的结果是 count 值的累加。

1.2 静态全局变量

在全局作用域内声明的变量，如果使用 static 关键字，则它就成为 静态全局变量。它的作用域只在当前文件内，不同文件中的同名变量是独立的。

// file1.cpp
#include <iostream>

static int count = 0;

void myFunc1() {
    count++;
}

// file2.cpp
#include <iostream>

extern int count;

void myFunc2() {
    count++;
}

int main() {
    myFunc1();
    myFunc2();
    std::cout << "count: " << count << std::endl; // output: count: 2
    return 0;
}

在以上代码中，在 file1.cpp 中声明了静态全局变量 count，其作用域只在 file1.cpp 里面。在 file2.cpp 中使用 extern 关键字声明了同名的变量 count，在函数调用结束后会将其值传递到全局变量 count 上，最终输出的结果是 count 值的累加。

1.3 静态成员变量和方法

在类内部声明的变量或方法，如果使用 static 关键字，则它就成为 静态成员变量或方法。静态成员变量是属于整个类的，而不是属于某个对象的；静态成员方法则不需要实例化对象即可调用。

#include <iostream>

class MyClass {
public:
    static int count; // 静态成员变量

    static void increment() { // 静态成员方法
        count++;
    }
};

int MyClass::count = 0; // 静态成员变量的初始化

int main() {
    MyClass::increment();
    MyClass::increment();
    std::cout << "count: " << MyClass::count << std::endl; // output: count: 2
    return 0;
}

在以上代码中，我们声明了 MyClass 类，并在其中定义了一个静态成员变量 count 和一个静态成员方法 increment。在 main 函数中，我们使用类名调用静态成员方法 increment，并输出静态成员变量 count 的值。注意，静态成员变量的初始化必须在类外进行。

2. Java 中的 static

在 Java 中，static 关键字也会与变量或方法一起使用，但有些不同。

2.1 静态变量

在 Java 中， static 可以与变量一起使用，但 Java 中没有静态局部变量的概念。静态变量也是属于整个类的而不是对象的。

public class MyClass {
    static int count; // 静态变量

    public static void main(String[] args) {
        MyClass.count++;
        System.out.println("count: " + MyClass.count); // output: count: 1
    }
}

在以上代码中，我们声明了 MyClass 类，并在其中定义了一个静态变量 count。在 main 函数中，我们直接使用类名调用静态变量 count，并且对其进行自增操作。Java 中的静态变量可以直接通过类名访问。

2.2 静态块

在 Java 中，可以使用静态块来对静态变量进行初始化操作。静态块只会在类被加载时执行一次。

public class MyClass {
    static int count;

    static {
        count = 100;
    }

    public static void main(String[] args) {
        System.out.println("count: " + MyClass.count); // output: count: 100
    }
}

在以上代码中，我们使用静态块对静态变量 count 进行了初始化赋值，最终输出 count 的值为 100。

2.3 静态方法

在 Java 中，可以使用 static 关键字来定义静态方法，它不需要实例化对象就可以直接调用。

public class MyClass {
    static int count;

    public static void increment() {
        count++;
    }

    public static void main(String[] args) {
        MyClass.increment();
        MyClass.increment();
        System.out.println("count: " + MyClass.count); // output: count: 2
    }
}

在以上代码中，我们定义了静态方法 increment，在 main 函数中直接使用类名调用 increment 方法进行计数，并输出静态变量 count 的值。

3. 总结

在 C++ 和 Java 中， static 关键字都可以与变量或方法一起使用，并且都是属于整个类而不是对象的。但是两种语言中的 static 的使用有些不同。在 C++ 中，静态变量的作用域可以限制在一个文件中，而在 Java 中没有这种概念；同时，在 C++ 中，静态局部变量的生命周期与程序一致，而在 Java 中静态变量的生命周期与 JVM 一致。静态方法在两种语言中的使用差异不大，但是在 Java 中静态方法必须在类中定义，而在 C++ 中可以在命名空间中定义。