java中static和const和final的区别及使用说明

java中static和const和final的区别及使用说明并不只看表面做法，关键还要理解相关条件、限制和后续影响。

static关键字

static 关键字用于声明类的成员（方法或变量）为静态成员。静态成员属于类本身，而不是类的实例。

换句话说，静态成员可以通过类名直接访问，而不需要实例化对象。

1. 静态变量：属于类的所有对象共享，类的所有实例共享相同的内存位置。
2. 静态方法：可以在没有创建对象的情况下直接调用。
3. 静态块：在类加载时执行一次，用于初始化类的静态成员。
4. 编译时机：static 关键字主要在编译时确定。它告诉 JVM，该成员属于类而非实例，因此不需要通过对象来访问。static 修饰的变量和方法会被加载到 方法区 中的 类的结构部分。
5. 内存存储位置：static 成员存储在 方法区 中的 类的静态变量区。每个类只有一个静态变量区，所有实例共享这部分内存。静态方法也存储在方法区的 方法区（Method Area） 中。

count 是静态变量，在两个 Counter 对象中共享，displayCount 是静态方法，可以通过类名直接调用。

class Counter {    static int count = 0;  // 静态变量        Counter() {        count++;  // 每次创建对象时，静态变量 count 会增加    }    static void displayCount() {        System.out.println("Count: " + count);  // 静态方法可以直接访问静态变量    }}public class Main {    public static void main(String[] args) {        Counter c1 = new Counter();        Counter c2 = new Counter();        Counter.displayCount();  // 调用静态方法，输出 Count: 2    }}

final关键字

final 是一个多用途的关键字，它可以用于变量、方法和类的定义，分别具有不同的含义。

1. 用于变量：声明为 final 的变量是常量，一旦赋值后不可更改（不可重新赋值）。
2. 用于方法：声明为 final 的方法不能被子类重写。
3. 用于类：声明为 final 的类不能被继承。
4. 编译时机：final 关键字的使用在编译时就确定了变量、方法或类的行为。例如，如果一个方法被声明为 final，编译器会禁止任何子类重写该方法；如果一个类被声明为 final，编译器会禁止任何子类继承该类。对于变量，final 确保该变量一旦赋值后不可修改。

内存存储位置：

1. final 变量：常量（final 变量）通常在 方法区 中的 常量池（Constant Pool） 中存储。如果是局部变量，存储在栈中。
2. final 类和方法：存储在 方法区 中的 类的结构部分。final 类和方法不会被继承或重写，因此它们在运行时不需要动态解析。

PI 被声明为 final，因此它的值不能更改。

// final 变量class Circle {    final double PI = 3.14159;  // 常量，值不可更改        void calculateArea(double radius) {        double area = PI * radius * radius;  // 使用常量        System.out.println("Area: " + area);    }}public class Main {    public static void main(String[] args) {        Circle circle = new Circle();        circle.calculateArea(5);        // PI = 3.14;  // 编译错误，无法修改 final 变量的值    }}

const关键字

在 Java 中，const 是一个保留关键字，但它并没有在语言中实现功能，实际上 Java 中并不使用 const 来定义常量。Java 提供了 final 来替代 const 的功能。

1. const 在 Java 中没有实现任何功能。
2. const 关键字保留用于未来可能的用途，但目前不被使用。
3. 常量在 Java 中应该使用 final 关键字来定义。
4. 编译时机：虽然 const 是 Java 中的保留关键字，但它并没有被实现。实际上，Java 没有使用 const 来定义常量。在 Java 中，我们通常使用 final 来定义常量。
5. 内存存储位置：由于 const 不被实际使用，它不会在内存中占用任何空间。任何常量都应该使用 final 来定义，并存储在 方法区的常量池 或堆栈中。

使用 const 会导致编译错误，因为 const 在 Java 中并没有实际作用。

// const 在 Java 中并不使用public class Main {    public static void main(String[] args) {        // const int x = 10;  // 编译错误，const 不被使用    }}

完整示例

class Person {    static String species = "Homo sapiens";  // 静态变量    final String name;  // 常量，必须在构造方法中初始化    Person(String name) {        this.name = name;    }    // final 方法，不能被子类重写    final void showDetails() {        System.out.println("Name: " + name + ", Species: " + species);    }}class Student extends Person {    Student(String name) {        super(name);    }    // 编译错误，无法重写 final 方法    // void showDetails() {     //     System.out.println("Student: " + name);    // }}public class Main {    public static void main(String[] args) {        Person person = new Person("Alice");        person.showDetails();  // 调用父类的 final 方法                // 通过类名访问静态变量        System.out.println("Species: " + Person.species);        // 修改静态变量        Person.species = "Homo erectus";        System.out.println("Updated Species: " + Person.species);        // name = "Bob";  // 编译错误，final 变量不可修改    }}

Java 内存区的详细说明

1.方法区（Method Area）

1. 存放内容：类的结构（包括类的元数据）、静态变量、常量池、方法代码等。
2. 静态成员和常量：static 成员变量和 final 常量通常存储在方法区中。静态方法也存储在方法区。常量则会存放在类的常量池（Constant Pool）中。

2.堆（Heap）

1. 存放内容：对象实例、数组、类的实例等。
2. final 变量（如果是对象引用）：如果 final 变量是引用类型，则它的引用会存放在栈中，但对象本身会存放在堆中。

3.栈（Stack）

1. 存放内容：局部变量、方法调用信息、操作数栈等。
2. final 局部变量：局部变量（如方法参数）如果是 final，则存储在栈上。

4.程序计数器（Program Counter Register）

1. 存放内容：每个线程都有一个程序计数器，指向当前执行的字节码指令。
2. final 修饰的局部变量（参数）：存储在栈上，而栈本身不直接与程序计数器相关联。

5.本地方法栈（Native Method Stack）

1. 存放内容：存放 native 方法的调用信息。

总结