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

概述

在 C++ 和 Java 中，static 关键字都具有不同的含义和功能。C++ 中 static 关键字常常出现在类和函数中，而 Java 中则更为常见，可以用于变量、方法和类。

本文将讨论 C++ 和 Java 中 static 关键字的异同点，以及它们的使用场景和用法。

C++ 中的 static 关键字

类中的 static 成员变量

在 C++ 中，类中的 static 成员变量与普通成员变量不同，其存储在全局数据区而非栈上，仅在程序运行时初始化一次，并且只有一份副本，被所有实例对象所共享。

#include <iostream>

using namespace std;

class Person {
public:
    static int count;  // 声明一个静态成员变量 count
    Person() {
        count++;  // 每次创建对象，count 的值加 1
    }
};

// 定义静态成员变量 count，并初始化为 0
int Person::count = 0;

int main() {
    Person p1, p2, p3;
    cout << "There are " << Person::count << " persons." << endl;
    return 0;
}

以上示例中，类 Person 中声明了一个静态成员变量 count，用于计数。在 main 函数中创建了三个对象 p1、p2 和 p3，每当创建一个对象时，count 的值都会自增。最终输出 “There are 3 persons.”。

静态成员函数

C++ 中的静态成员函数属于类，而非对象。它们没有 this 指针，因此无法访问非静态成员变量和非静态成员函数，只能访问静态成员变量和静态成员函数。

#include <iostream>

using namespace std;

class Calculator {
public:
    static int add(int x, int y) {  // 静态成员函数
        return x + y;
    }
};

int main() {
    int result = Calculator::add(3, 4);
    cout << "Result is " << result << endl;
    return 0;
}

以上示例中，类 Calculator 中声明了一个静态成员函数 add，用于计算两个数的和。在 main 函数中使用 Calculator::add(3, 4) 调用静态成员函数，输出结果 “Result is 7.”。

文件作用域

C++ 中的 static 关键字还可以用于限定全局变量和函数的作用域为文件作用域。在文件中定义一个 static 全局变量或函数后，其作用域只限于当前文件内，且不会与其它文件中的同名全局变量或函数产生冲突。

// a.cpp
#include <iostream>

static int num = 0;

void func() {
    num++;
    std::cout << "a.cpp: " << num << std::endl;
}

// b.cpp
#include <iostream>

static int num = 0;

void func() {
    num++;
    std::cout << "b.cpp: " << num << std::endl;
}

int main() {
    func();  // 输出 a.cpp: 1
    func();  // 输出 a.cpp: 2
    func();  // 输出 a.cpp: 3
    return 0;
}

以上示例中，文件 a.cpp 和 b.cpp 中分别定义了一个同名的静态全局变量 num 和函数 func。由于 static 关键字的存在，它们分别作用于 a.cpp 和 b.cpp 文件内，且不会互相影响。在 main 函数中依次调用 func 函数，输出 a.cpp: 1、a.cpp: 2 和 a.cpp: 3。

Java 中的 static 关键字

静态方法

Java 中的静态方法与 C++ 中的静态成员函数类似，属于类，而非对象。它们无法访问非静态变量和非静态方法，只能访问静态变量和静态方法。

public class Calculator {
    public static int add(int x, int y) {  // 静态方法
        return x + y;
    }
}

public class Main {
    public static void main(String[] args) {
        int result = Calculator.add(3, 4);
        System.out.println("Result is " + result);
    }
}

以上示例中，定义了一个 Calculator 类并在其中声明了一个 add 静态方法。在 main 函数中使用 Calculator.add(3, 4) 调用静态方法，输出结果 “Result is 7.”。

静态变量

Java 中的静态变量与 C++ 中的静态成员变量类似，都在类级别上定义，仅被实例化一次，被所有类的对象所共享。在 Java 中，静态变量可以用 static 关键字修饰。

public class Person {
    public static int count;  // 静态变量
    public Person() {
        count++;  // 每当创建对象时，count 的值加 1
    }
}

public class Main {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();
        Person p3 = new Person();
        System.out.println("There are " + Person.count + " persons.");
    }
}

以上示例中，定义了一个 Person 类并声明了一个 count 静态变量，表示已创建的 Person 对象数目。在 main 函数中创建了三个 Person 对象，并输出结果 “There are 3 persons.”。

静态代码块

Java 中的静态代码块与 C++ 中的文件作用域类似，用于在类加载时执行一些初始化操作。在 Java 中，静态代码块使用 static 关键字修饰，可以用于初始化静态变量或加载静态资源。

public class Calculator {
    static {
        System.out.println("Calculator is loaded.");  // 执行初始化操作
    }
    public static int add(int x, int y) {
        return x + y;
    }
}

public class Main {
    public static void main(String[] args) {
        int result = Calculator.add(3, 4);
        System.out.println("Result is " + result);
    }
}

以上示例中，定义了一个 Calculator 类并在其中定义了一个静态代码块。每当程序加载该类时，静态代码块就会被执行一次，并输出 “Calculator is loaded.” 的初始化信息。在 main 函数中使用 Calculator.add(3, 4) 调用静态方法，输出结果 “Result is 7.”。

结论

总的来说，C++ 和 Java 中的 static 关键字有很多相似之处，但也存在一些差异。在 C++ 中，static 关键字主要用于限定类成员的作用域和内存存储方式，而在 Java 中，static 关键字则广泛应用于变量、方法和类的定义和使用。在实际开发中，程序员应根据具体情况选择合适的 static 关键字，以提高代码的可读性和效率。