Java static 关键字

最后修改时间 2025 年 5 月 1 日

在本文中，我们将介绍 Java 中的 static 关键字。我们将涵盖静态变量、方法、嵌套类、块和导入。

定义

static 关键字是 Java 中的一个非访问修饰符。当应用于类的成员时，它确保该成员属于类本身，而不是类的实例。这意味着 static 成员在所有实例之间共享，并且不需要对象实例化即可访问。

此外，static 关键字可以用于

类初始化器（在类加载时执行的静态块）。
常量（在实例之间共享的静态 final 变量）。
静态导入（允许直接访问静态成员，而无需类限定）。

static 关键字的用法

static 修饰符可以应用于以下组件

变量 - 在类的所有实例之间共享。
方法 - 无需类的实例即可调用。
块 - 用于类级别的初始化。
嵌套类 - 不依赖于外部类实例的内部类。
导入 - 允许直接访问其他类中的静态成员。

Java 静态变量

静态变量也称为类变量。类的所有实例共享同一个静态变量的副本。它们只在执行开始时初始化一次。可以通过类名直接访问类变量，无需创建实例。static 的一个常见用途是创建一个附加到类的常量值。

静态变量示例

Main.java

import java.util.ArrayList;
import java.util.List;

class Being {

    public static int count;
}

class Cat extends Being {

    public Cat() {
        count++;
    }
}

class Dog extends Being {

    public Dog() {
        count++;
    }
}

class Donkey extends Being {

    public Donkey() {
        count++;
    }
}


void main(String[] args) {

    List<Being> beings = new ArrayList<>();

    beings.add(new Cat());
    beings.add(new Cat());
    beings.add(new Cat());
    beings.add(new Dog());
    beings.add(new Donkey());

    int nOfBeings = Being.count;

    System.out.format("There are %d beings %n", nOfBeings);
}

在代码示例中，我们使用静态变量来跟踪已创建的 beings。

class Being {

    public static int count;
}

定义了一个静态变量。该变量属于 Being 类，并由 Being 的所有实例（包括后代）共享。

class Cat extends Being {

    public Cat() {
        count++;
    }
}

Cat 类继承自 Being。它递增 count 变量。

class Dog extends Being {

    public Dog() {
        count++;
    }
}

Dog 类递增相同的类变量。因此，Dog 和 Cat 指的是同一个类变量。

int nOfBeings = Being.count;

我们获取创建的所有 beings 的数量。我们通过其类名后跟点运算符和变量名来引用类变量。

Java 静态变量属性

静态变量具有默认值。
可以在静态和非静态方法中直接访问静态变量。
静态变量称为类变量或静态字段。
静态变量与类关联，而不是与任何对象关联。

Java 静态方法

静态方法在没有对象实例的情况下被调用。要调用静态方法，我们使用类名、点运算符和方法名。静态方法只能使用静态变量。静态方法通常用于表示不会因对象状态而改变的数据或计算。例如，java.lang.Math 包含用于各种计算的静态方法。

我们使用 static 关键字来声明静态方法。如果没有 static 修饰符，则该方法被称为实例方法。

静态方法限制

静态方法只能调用其他静态方法。它们只能访问静态数据，不能引用 this 和 super。

静态方法示例

com/zetcode/Main.java

package com.zetcode;

class Basic {

    static int id = 2321;

    public static void showInfo() {

        System.out.println("This is Basic class");
        System.out.format("The Id is: %d%n", id);
    }
}

public class Main {

    public static void main(String[] args) {

        Basic.showInfo();
    }
}

在我们的代码示例中，我们定义了一个静态的 ShowInfo 方法。

static int id = 2321;

静态方法只能使用静态变量。静态变量对于实例方法不可用。

public static void showInfo() {

    System.out.println("This is Basic class");
    System.out.format("The Id is: %d%n", id);
}

这是我们的静态 ShowInfo 方法。它使用静态 id 成员。

Basic.showInfo();

要调用静态方法，我们不需要对象实例。我们使用类名和点运算符来调用该方法。

静态 main 方法

在 Java 控制台和 GUI 应用程序中，入口点具有以下签名

public static void main(String[] args)

通过声明 main 方法为 static，运行时引擎可以调用它，而无需创建 main 类的实例。由于 main 的主要原因是引导应用程序，因此不需要 main 类的实例。

此外，如果 main 方法不是 static，则需要额外的约束，例如默认构造函数或要求 main 类不是抽象的。因此，使用 static main 方法是一种更简单的解决方案。

Java 静态块

具有 static 修饰符的代码块称为类初始化器。没有 static 修饰符的代码块是实例初始化器。类初始化器在类加载时按定义的顺序（从上到下）执行。

静态块在任何程序的生命周期中只执行一次，并且没有其他方法可以调用它。

静态块示例

Main.java

package com.zetcode;

public class Main {

    private static final int i;

    static {

        System.out.println("Class initializer called");
        i = 6;
    }

    public static void main(String[] args) {

        System.out.println(i);
    }
}

这是一个静态初始化器的示例。

static {

    System.out.println("Class initializer called");
    i = 6;
}

在静态初始化器中，我们向控制台打印一条消息并初始化一个静态变量。

静态嵌套类

静态嵌套类是一个嵌套类，可以在没有封闭类实例的情况下创建。它可以访问封闭类的静态变量和方法。

静态嵌套类可以逻辑地分组仅在一个地方使用的类。它们增加了封装性，并提供更具可读性和可维护性的代码。

静态嵌套类限制

静态嵌套类不能调用非静态方法或访问封闭类实例的非静态字段。

静态嵌套类示例

Main.java

package com.zetcode;

public class Main {

    private static int x = 5;

    static class Nested {

        @Override
        public String toString() {
            return "This is a static nested class; x:" + x;
        }
    }

    public static void main(String[] args) {

        Main.Nested sn = new Main.Nested();
        System.out.println(sn);
    }
}

该示例演示了一个静态嵌套类。

private static int x = 5;

这是 JavaStaticNestedClass 类的私有静态变量。它可以由静态嵌套类访问。

static class Nested {

    @Override
    public String toString() {
        return "This is a static nested class; x:" + x;
    }
}

定义了一个静态嵌套类。它有一个方法，该方法打印一条消息并引用静态 x 变量。

Main.Nested sn = new Main.Nested();

点运算符用于引用嵌套类。

Java 静态导入

静态导入允许将在类中定义为 public static 的成员（字段和方法）在 Java 代码中使用，而无需指定定义该字段的类。

静态导入缺点

过度使用静态导入功能可能会使我们的程序变得不可读且不可维护，从而用我们导入的所有静态成员污染其命名空间。

静态导入示例

Main.java

package com.zetcode;

import static java.lang.Math.PI;

public class Main {

    public static void main(String[] args) {

        System.out.println(PI);
    }
}

在该示例中，我们使用 PI 常量而不使用其类。

Java 常量

static 修饰符与 final 修饰符结合使用，也用于定义常量。 final 修饰符指示此字段的值不能更改。

public static final double PI = 3.14159265358979323846;

例如，在 java.lang.Math 中，我们有一个名为 PI 的常量，其值是 pi 的近似值（圆的周长与其直径的比率）。

单例模式

单例设计模式确保在应用程序的生命周期内只构造一个特定类的对象。

Singleton.java

public class Singleton {

    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return INSTANCE;
    }
}

在这个简单的代码摘录中，我们有一个对单个允许对象实例的内部静态引用。我们通过静态方法访问该对象。

来源

Java 教程

在本文中，我们介绍了 Java static 关键字。

作者

我叫 Jan Bodnar，是一位充满热情的程序员，拥有丰富的编程经验。我从 2007 年开始撰写编程文章。到目前为止，我已经撰写了 1,400 多篇文章和 8 本电子书。我拥有超过十年的编程教学经验。

列出所有Java教程。