static-final关键字_14

static关键字

static 是 Java 中的一个关键字，用于修饰类的成员（变量、方法、代码块和内部类）。static 成员属于类本身，而不是类的实例

类级别：static 成员属于类，而不是类的实例。
共享性：所有实例共享同一个 static 成员。
直接访问：可以通过类名直接访问 static 成员，无需创建对象
static 变量存储在方法区（Method Area）中，java8之后在堆内存的class字节码对象最后（不确定）
在类的准备（Preparation）阶段JVM 为 static 变量分配内存，将 static 变量初始化为默认值
在类的初始化（Initialization）阶段进行赋值，静态变量赋值和静态代码块的执行顺序按照定义顺序依次执行
如果 static 变量是常量（static final），则在准备阶段直接赋值为指定的值

静态变量

静态变量属于类，而不是实例。
所有实例共享同一个静态变量。

通常用于表示类的全局状态或常量。

class Counter {
    static int count = 0; // 静态变量

    Counter() {
        count++; // 每次创建对象时，count 增加
    }
}

public class Main {
    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();

        System.out.println(Counter.count); // 输出：2
    }
}

静态方法

静态方法属于类，而不是实例。
可以直接通过类名调用，无需创建对象。

静态方法中不能直接访问实例成员（变量或方法），只能访问静态成员

class MathUtils {
    static int add(int a, int b) { // 静态方法
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        int result = MathUtils.add(5, 10); // 直接通过类名调用
        System.out.println(result); // 输出：15
    }
}

静态代码块

静态代码块在类加载时执行，且只执行一次。

通常用于初始化静态变量或执行一些静态初始化操作

class MyClass {
    static int value;

    static { // 静态代码块
        value = 10;
        System.out.println("Static block executed");
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(MyClass.value); // 输出：Static block executed
                                           //       10
    }
}

补充执行顺序

父类静态代码块→ 子类静态代码块→父类属性默认初始化 → 父类显式赋值 → 父类构造器 → 子类属性默认初始化 → 子类显式赋值 → 子类构造器

静态内部类

静态内部类属于外部类，而不是外部类的实例。

可以直接通过外部类名访问，无需创建外部类对象。

class Outer {
    static class Inner { // 静态内部类
        void display() {
            System.out.println("Inside static inner class");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner(); // 直接通过外部类名访问
        inner.display(); // 输出：Inside static inner class
    }
}

final关键字

final 是 Java 中的一个关键字，用于修饰类、方法和变量。它的作用是限制被修饰元素的修改或继承
final修饰的变量也有赋默认值这一过程，不过如果 final 变量在声明时赋值（如 final int value = 10;），它会在类加载的准备阶段被赋值，如果在构造器中赋值，则仍然会出现多态中的潜在问题
final 变量的初始化优先于非 final 变量

final修饰类

不可继承：final 类不能被其他类继承
final 修饰的类称为最终类，无法被其他类继承。例如 Java 标准库中的 String 和 Integer 均为 final 类，防止核心功能被修改

final修饰方法

不可重写：final 方法不能被子类重写（该final方法会被子类继承）
final 方法不能被子类重写（Override），但可以重载（Overload）
类的 private 方法默认隐式声明为 final，即使子类声明同名方法也不算重写

final修饰变量

局部变量：一旦赋值后，不能再修改，可以在声明时或第一次使用时初始化
实例变量：必须在声明时或构造器中初始化，且不能重新赋值
静态变量：必须在声明时或静态代码块中初始化，且不能重新赋值

基本类型变量
- 值不可变：一旦初始化后，数值不能修改
- 初始化方式：声明时赋值或在构造器中赋值（成员变量必须满足其一）
引用类型变量
- 引用不可变：变量指向的对象地址不可更改
- 对象内容可变：对象内部的属性或状态可以修改
静态常量
- static final 联合修饰的变量是全局常量，命名通常使用大写字母和下划线

final的特点

线程安全：final 变量在多线程环境下是线程安全的
性能优化：JVM 可以对 final 变量进行优化

final static 组合修饰符

final static 组合修饰符用于定义类级别的不可变常量，兼具 final（不可变性）和 static（类级作用域）的特性

final static 组合修饰符只能修饰变量，不能修饰方法或类。这是因为 final 和 static 在修饰方法和类时的作用是独立的，组合使用没有意义，甚至会导致语法错误

final static修饰基本类型变量
- 变量属于类，所有实例共享。
- 变量一旦赋值后，不能再修改
- final static 修饰的基本数据类型变量是全局类常量，内存分配在方法区（元空间），且不可重新赋值
- 必须在声明时或静态代码块中赋值，否则编译报错
- 如果常量值在编译期可确定（如 int、String 字面量），编译器会直接将常量值内联到使用处，无需通过类名访问（无需加载该类）
final static修饰引用类型变量
- 变量属于类，所有实例共享。
- 变量的引用（内存地址）一旦赋值后，不能再修改。
- 如果引用指向的对象是可变的（如数组、ArrayList 等），则对象的内容可以修改
- 如果引用指向的对象是不可变的（如 String，Integer等），则对象的内容也不能修改

posted @ 2025-03-03 21:54 QAQ001 阅读(21) 评论(0) 收藏举报

刷新页面返回顶部

Learn-Review-blog