Java 初学者：什么是静态变量？

Java中的静态变量是什么，它们有什么用？静态变量是与类相关联的变量，而不是与该类的对象相关联的变量。

让我们看一个例子。为了使事情尽可能简单，我们将使用一个public 静态变量。如果您还没有遇到public ，请不要担心！在这些特定的例子中，实际上并没有什么区别。

假设您定义了一个如下所示的类，其中只有一个公共静态变量。

Stuff.java:

public class Stuff {
    public static String name = "I'm a static variable";
}

我们已经声明了一个名为“Stuff”的类，并为其提供了一个 String 类型的公共静态变量。我们已经将变量初始化为字符串值“我是一个静态变量”。

现在我们可以像这样在我们的主程序中使用这个类：

Application.java：

public class Application {
    
    public static void main(String[] args) {
        System.out.println(Stuff.name);
    }

}

I'm a static variable

这里Application类的点只是给我们一个地方放一个main方法，就是程序的入口（起点）点。

您可以看到我们可以愉快地访问 Stuff 类中的“name”实例变量，而无需实际创建 Stuff 类型的对象。我们可以直接使用 Stuff 类。那是因为变量是

static，因此属于该类，而不是该类的任何特定对象。 我们将它声明为public的事实允许我们从其他类（在本例中为应用程序）访问它。尽管实际上在

这个例子中public关键字是多余的，因为我们没有提到任何包名。

使用静态关键字创建常量

static的一个常见用途是创建一个附加到类的常量值。我们需要对上述示例进行的唯一更改是在其中添加关键字final，以使 ‘name’ 成为常量（换句话说，防止它被更改）。

我们还应该按照惯例将 ‘name’ 大写，以表明它是一个常量。这不是绝对必要的。这实际上只是一个约定。

public class Stuff {
    public final static String NAME = "I'm a static variable";
}

public class Application {
    
    public static void main(String[] args) {
        System.out.println(Stuff.NAME);
    }

}

I'm a static variable

使用静态变量对对象进行计数

static 的另一个经典用途是计算从给定类创建的对象数量。

首先，让我们快速回顾一下构造函数。

构造函数的快速复习

我们将更改“Stuff”类，使其具有不接受参数的构造函数。构造函数只是一种在创建对象时运行的特殊方法。构造函数与类同名，没有返回类型，甚至没有 void。您应该将其声明为public，以便始终可以从类本身外部调用它（否则您将无法从类创建对象，至少不能在包之外创建对象）。

public class Stuff {
    public Stuff() {
        System.out.println("Stuff object constructed!");
    }
}

您可以看到我还添加了一个 println 语句，以便我们可以看到构造函数何时运行。

现在我们将修改“main”方法，使其创建三个“Stuff”类型的对象。

public class Application {
    
    public static void main(String[] args) {
        Stuff stuff1 = new Stuff();
        Stuff stuff2 = new Stuff();
        Stuff stuff3 = new Stuff();
    }

}

你认为输出会是什么样子？

Stuff object constructed!
Stuff object constructed!
Stuff object constructed!

每次构造 Stuff 对象时，构造函数都会运行。

计数对象

假设我们要计算每个创建的对象。每次创建新的 Stuff 对象时，我们都需要增加一个变量。如果我们想在类本身中执行此操作，我们如何使变量在对象之间保持不变？我们需要将其声明为static ，以便它成为类的一部分，而不是任何单个对象的一部分。

public class Stuff {
    
    // Set count to zero initially.
    static int count = 0;
    
    public Stuff() {
        
        // Every time the constructor runs, increment count.
        count = count + 1;
        
        // Display count.
        System.out.println("Created object number: " + count);
    }
}

静态计数变量在它被创建的那一刻被设置为 0，就在它被声明的地方。但是每次随后调用构造函数时（通过在’main’方法中创建一个新对象），它都会增加计数。

因此，我们有效地计算了创建了多少对象。

尽管 count 是类的一部分，而不是单个对象的一部分，但是单个对象仍然可以用它做一些事情。

猜测现在的输出会是什么样子？

Created object number: 1
Created object number: 2
Created object number: 3

为对象分配 ID

现在我们正在计算对象，我们可以使用计数为每个对象分配一个 ID。

我们不能使用 ‘count’ 本身作为 ID，因为每次创建新对象时它都会改变。

我们需要创建一个实例（每个对象）变量来存储 ID。然后我们可以在构造函数中使用 ‘count’ 设置 ID 变量！

我们还将添加一个 getId() 方法，以便“main”方法可以获取 ID。

public class Stuff {
    
    // Set count to zero initially.
    static int count = 0;
    
    // Use this to store an ID for each object.
    int id;
    
    public Stuff() {
        
        // Every time the constructor runs, increment count.
        count = count + 1;
        
        // Set the object ID using count.
        id = count;
        
        // Now count can change but id will be unaffected.
    }
    
    // This just returns the ID.
    public int getId() {
        return id;
    }
}

让我们修改’main’，让它检索并显示它创建的第二个对象的ID。

public class Application {
    
    public static void main(String[] args) {
        Stuff stuff1 = new Stuff();
        Stuff stuff2 = new Stuff();
        Stuff stuff3 = new Stuff();
        
        System.out.println("ID of object 2 is: " + stuff2.getId());
    }

}

你知道输出会是什么，对吧？

ID of object 2 is: 2

当然，第一个对象的 ID 为 1，第三个对象的 ID 为 3，以此类推。

每个对象都有自己独立的 ID，该 ID 在构造函数中使用静态“count”变量设置。

如果您能遵循这一点，那么您就掌握了静态变量的窍门。他们没有更多的东西。稍后你肯定会遇到静态初始化块和单例对象，现在你已经有了坚实的基础，这甚至不会让你头疼。