【Java基础】Java 中的 static 关键字

李少兄

已于 2025-02-20 21:33:52 修改

阅读量1.7k

点赞数 64

分类专栏： # Java基础文章标签： java 开发语言

于 2025-02-20 09:30:00 首次发布

本文链接：https://blog.csdn.net/wenxuankeji/article/details/145739977

版权

Java基础专栏收录该内容

24 篇文章

订阅专栏

一、前言

在 Java 的编程世界里，static 关键字是一个非常重要且实用的特性。它就像是一把神奇的钥匙，能够改变变量、方法、代码块和内部类的性质和行为。

二、static 修饰成员变量

2.1 静态变量的基本概念

在 Java 里，当我们使用 static 关键字修饰成员变量时，这个变量就变成了静态变量，也叫类变量。普通的成员变量（实例变量）是每个对象都有一份独立的副本，而静态变量不同，它属于整个类，无论创建多少个该类的对象，静态变量在内存中只有一份。

想象一下，我们要统计一个学校里学生的总数。如果用实例变量来记录，每个学生对象都有一个自己的“学生总数”变量，这显然是不合理的。而使用静态变量，就可以让所有学生对象共享这个“学生总数”变量，方便又准确。

2.2 静态变量的声明与访问

静态变量的声明很简单，只需要在变量类型前面加上 static 关键字就行。下面是一个具体的例子：

// 定义一个学生类
class Student {
    // 静态变量，用于记录学生的总数
    public static int studentCount = 0;
    // 实例变量，用于记录学生的姓名
    public String name;

    // 构造方法，每次创建学生对象时，学生总数加 1
    public Student(String name) {
        this.name = name;
        studentCount++;
    }
}

public class StaticVariableExample {
    public static void main(String[] args) {
        // 创建第一个学生对象
        Student student1 = new Student("张三");
        // 创建第二个学生对象
        Student student2 = new Student("李四");

        // 直接通过类名访问静态变量
        System.out.println("当前学生的总数是：" + Student.studentCount);

        // 也可以通过对象访问静态变量，但不推荐
        System.out.println("通过对象访问学生总数：" + student1.studentCount);
    }
}

在这个例子中，studentCount 就是一个静态变量。每次创建一个新的 Student 对象时，构造方法会将 studentCount 的值加 1。我们可以直接通过类名 Student 来访问这个静态变量，当然也可以通过对象来访问，但为了代码的清晰性，推荐使用类名访问。

2.3 静态变量的初始化

静态变量的初始化有两种常见的方式：

2.3.1 声明时初始化

我们可以在声明静态变量的同时给它赋值。例如：

class School {
    // 声明静态变量并初始化
    public static String schoolName = "阳光小学";
}

这样，schoolName 这个静态变量在类加载的时候就被初始化为 "阳光小学" 了。

2.3.2 静态代码块初始化

静态代码块是使用 static 关键字修饰的代码块，它会在类加载时执行，而且只执行一次。我们可以利用静态代码块来初始化静态变量。示例如下：

class Library {
    // 声明静态变量
    public static int bookCount;

    // 静态代码块，用于初始化静态变量
    static {
        System.out.println("正在初始化图书馆的图书数量...");
        bookCount = 1000;
    }
}

public class StaticInitializationExample {
    public static void main(String[] args) {
        System.out.println("图书馆的图书数量是：" + Library.bookCount);
    }
}

在这个例子中，当 Library 类被加载时，静态代码块会先执行，输出初始化信息，并将 bookCount 初始化为 1000。然后在 main 方法中，我们就可以访问到已经初始化好的 bookCount 变量了。

2.4 静态变量的内存分配

静态变量在类加载的时候就会被分配内存，存储在方法区中。只要类存在，静态变量就一直存在，直到类被卸载。这和实例变量不同，实例变量是在创建对象时才分配内存，存储在堆中，对象被垃圾回收后，实例变量的内存也会被释放。

三、static 修饰成员方法

3.1 静态方法的基本概念

使用 static 关键字修饰的成员方法就是静态方法，也叫类方法。和静态变量一样，静态方法属于整个类，而不是某个具体的对象。我们可以直接通过类名来调用静态方法，不需要创建类的对象。

比如，我们有一个数学工具类，里面有一些通用的数学计算方法，像加法、乘法等。这些方法不需要依赖某个具体的对象，就可以设计成静态方法。

3.2 静态方法的声明与调用

静态方法的声明很简单，在方法返回类型前面加上 static 关键字即可。下面是一个示例：

// 定义一个数学工具类
class MathUtils {
    // 静态方法，用于计算两个整数的和
    public static int add(int a, int b) {
        return a + b;
    }

    // 实例方法，用于打印一条消息
    public void printMessage() {
        System.out.println("这是一个数学工具类。");
    }
}

public class StaticMethodExample {
    public static void main(String[] args) {
        // 直接通过类名调用静态方法
        int result = MathUtils.add(3, 5);
        System.out.println("3 和 5 相加的结果是：" + result);

        // 需要创建对象才能调用实例方法
        MathUtils mathUtils = new MathUtils();
        mathUtils.printMessage();
    }
}

在这个例子中，add 方法是静态方法，我们可以直接通过类名 MathUtils 调用它。而 printMessage 方法是实例方法，需要先创建 MathUtils 类的对象，然后通过对象来调用。

3.3 静态方法的使用限制

静态方法在使用时有一些限制，主要有以下两点：

3.3.1 只能访问静态成员

静态方法只能直接访问类的静态变量和静态方法，不能直接访问实例变量和实例方法。这是因为静态方法在类加载时就已经存在，而实例变量和实例方法需要创建对象后才会存在。如果要访问实例成员，需要先创建对象。例如：

class MyClass {
    // 静态变量
    public static int staticVar = 10;
    // 实例变量
    public int instanceVar = 20;

    // 静态方法
    public static void staticMethod() {
        // 可以直接访问静态变量
        System.out.println("静态变量的值是：" + staticVar);

        // 错误：静态方法不能直接访问实例变量
        // System.out.println("实例变量的值是：" + instanceVar);

        // 正确：通过创建对象来访问实例变量
        MyClass obj = new MyClass();
        System.out.println("通过对象访问实例变量的值是：" + obj.instanceVar);
    }
}

3.3.2 不能使用 `this` 和 `super` 关键字

this 关键字代表当前对象，super 关键字用于访问父类的成员。由于静态方法不属于任何对象，所以在静态方法中不能使用 this 和 super 关键字。

3.4 静态方法的应用场景

静态方法常用于以下场景：

工具类：像 Java 中的 Math 类，里面的 sqrt、sin 等方法都是静态方法，方便我们直接调用进行数学计算。
单例模式：在单例模式中，通常会使用静态方法来获取单例对象。

四、static 修饰代码块

4.1 静态代码块的基本概念

静态代码块是使用 static 关键字修饰的代码块，它会在类加载时自动执行，而且只执行一次。静态代码块通常用于对静态变量进行初始化，或者执行一些只需要执行一次的操作，比如加载配置文件、初始化数据库连接等。

4.2 静态代码块的使用

静态代码块的语法如下：

static {
    // 代码块的内容
}

下面是一个示例，展示了静态代码块的使用：

// 定义一个游戏类
class Game {
    // 静态变量，用于记录游戏的版本号
    public static String gameVersion;

    // 静态代码块，用于初始化游戏的版本号
    static {
        System.out.println("正在加载游戏配置...");
        gameVersion = "2.0.0";
    }

    public static void main(String[] args) {
        System.out.println("游戏的版本号是：" + gameVersion);
    }
}

在这个例子中，当 Game 类被加载时，静态代码块会首先执行，输出加载游戏配置的信息，并将 gameVersion 初始化为 "2.0.0"。然后在 main 方法中，我们就可以访问到已经初始化好的 gameVersion 变量了。

4.3 静态代码块与构造代码块、构造方法的执行顺序

在 Java 中，静态代码块、构造代码块和构造方法的执行顺序是：静态代码块（类加载时执行，只执行一次） -> 构造代码块（每次创建对象时执行） -> 构造方法（每次创建对象时执行）。下面是一个示例代码，帮助我们理解它们的执行顺序：

// 定义一个示例类
class Example {
    // 静态代码块
    static {
        System.out.println("静态代码块正在执行...");
    }

    // 构造代码块
    {
        System.out.println("构造代码块正在执行...");
    }

    // 构造方法
    public Example() {
        System.out.println("构造方法正在执行...");
    }
}

public class ExecutionOrderExample {
    public static void main(String[] args) {
        System.out.println("创建第一个对象...");
        Example obj1 = new Example();

        System.out.println("创建第二个对象...");
        Example obj2 = new Example();
    }
}

运行上述代码，输出结果如下：

静态代码块正在执行...
创建第一个对象...
构造代码块正在执行...
构造方法正在执行...
创建第二个对象...
构造代码块正在执行...
构造方法正在执行...

从输出结果可以看出，静态代码块在类加载时只执行了一次，而构造代码块和构造方法在每次创建对象时都会执行。

五、静态内部类

5.1 静态内部类的基本概念

使用 static 关键字修饰的内部类就是静态内部类。和非静态内部类不同，静态内部类不依赖于外部类的实例，可以直接创建对象。静态内部类可以有自己的静态成员和实例成员。

5.2 静态内部类的声明与使用

静态内部类的声明方式是在内部类声明前加上 static 关键字。下面是一个示例，展示了静态内部类的使用：

// 定义一个汽车类
class Car {
    // 静态变量，记录汽车的品牌
    public static String brand = "宝马";
    // 实例变量，记录汽车的颜色
    public String color;

    // 静态内部类，代表汽车的发动机
    public static class Engine {
        // 静态内部类的实例变量，记录发动机的功率
        public int power;

        // 静态内部类的构造方法
        public Engine(int power) {
            this.power = power;
        }

        // 静态内部类的方法，用于打印发动机的信息
        public void printEngineInfo() {
            // 静态内部类可以直接访问外部类的静态成员
            System.out.println(brand + " 汽车的发动机功率是：" + power + " 马力");
        }
    }
}

public class StaticInnerClassExample {
    public static void main(String[] args) {
        // 直接创建静态内部类的对象
        Car.Engine engine = new Car.Engine(200);
        engine.printEngineInfo();
    }
}

在这个例子中，Engine 是一个静态内部类，我们可以直接通过 Car.Engine 来创建 Engine 类的对象。静态内部类可以直接访问外部类的静态成员，但如果要访问外部类的实例成员，需要通过外部类的对象来访问。

5.3 静态内部类的特点

不依赖外部类实例：可以直接创建静态内部类的对象，不需要先创建外部类的对象。
访问限制：静态内部类不能直接访问外部类的实例成员，除非通过外部类的对象来访问。
自身成员：静态内部类可以有自己的静态成员和实例成员。

六、static 关键字的高级应用与扩展

6.1 单例模式中的应用

单例模式是一种设计模式，它确保一个类只有一个实例，并提供一个全局访问点。static 关键字在单例模式中起着关键作用。下面是一个简单的单例模式示例：

// 单例模式示例
class Singleton {
    // 静态变量，用于保存单例实例
    private static Singleton instance;

    // 私有构造方法，防止外部创建对象
    private Singleton() {}

    // 静态方法，用于获取单例实例
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

public class SingletonExample {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        System.out.println("singleton1 和 singleton2 是否为同一个对象：" + (singleton1 == singleton2));
    }
}

在这个例子中，instance 是一个静态变量，用于保存单例实例。getInstance 是一个静态方法，用于获取单例实例。通过这种方式，我们可以确保 Singleton 类只有一个实例。

6.2 静态导入

静态导入是 Java 5 引入的一个特性，它允许我们直接使用类的静态成员，而不需要通过类名来访问。静态导入可以使代码更加简洁。示例如下：

// 静态导入 Math 类的所有静态成员
import static java.lang.Math.*;

public class StaticImportExample {
    public static void main(String[] args) {
        // 直接使用 sqrt 方法，无需通过 Math 类名
        double result = sqrt(16);
        System.out.println("16 的平方根是：" + result);
    }
}

在这个例子中，我们使用 import static java.lang.Math.*; 静态导入了 Math 类的所有静态成员，这样在 main 方法中就可以直接使用 sqrt 方法，而不需要通过 Math.sqrt 来调用。

七、总结

static 关键字在 Java 中是一个非常强大的工具，它可以修饰成员变量、成员方法、代码块和内部类，改变它们的性质和使用方式。静态变量和静态方法属于类本身，所有对象共享静态变量，通过类名可以直接调用静态方法。静态代码块在类加载时执行，用于初始化静态变量或执行一次性操作。静态内部类不依赖于外部类的实例，可以直接创建对象。