静态意味着“与类相关联”;没有它，变量与类的每个实例相关联。如果它是静态的，这意味着内存中只有一个;如果没有，您将为创建的每个实例创建一个。静态意味着只要类被加载，变量就会保留在内存中;如果没有它，当变量的实例被回收时，变量就会被回收。

虽然其他答案似乎很清楚地表明，通常没有理由使用非静态常数，但我找不到任何人指出，可以在常量变量上使用不同值的各种实例。

考虑下面的例子:

public class TestClass {
    private final static double NUMBER = Math.random();

    public TestClass () {
        System.out.println(NUMBER);
    }
}

创建三个TestClass实例将打印三次相同的随机值，因为只生成一个值并将其存储到静态常量中。

但是，当尝试下面的例子时:

public class TestClass {
    private final double NUMBER = Math.random();

    public TestClass () {
        System.out.println(NUMBER);
    }
}

创建三个TestClass实例现在将打印三个不同的随机值，因为每个实例都有自己随机生成的常量值。

我想不出在任何情况下，在不同的实例上有不同的常量值是真正有用的，但我希望这有助于指出静态韵母和非静态韵母之间有明显的区别。

静态变量在应用程序的整个生命周期中都保留在内存中，并在类加载期间初始化。每次构造一个新对象时，都会初始化一个非静态变量。通常更好的方法是:

private static final int NUMBER = 10;

为什么?这减少了每个实例的内存占用。它可能也有利于缓存命中。这是有意义的:静态应该用于在特定类型(类)的所有实例(也就是对象)之间共享的东西。

如果你使用static，变量的值将在你所有的实例中是相同的，如果在一个实例中改变了，其他实例也会改变。

通常，静态意味着“与类型本身相关联，而不是与类型的实例相关联”。

这意味着您可以在不创建类型实例的情况下引用静态变量，并且引用该变量的任何代码都引用完全相同的数据。将其与实例变量进行比较:在这种情况下，类的每个实例都有一个独立的变量版本。例如:

Test x = new Test();
Test y = new Test();
x.instanceVariable = 10;
y.instanceVariable = 20;
System.out.println(x.instanceVariable);

y. instancvariable和x. instancvariable是分开的，因为x和y指向不同的对象。

您可以通过引用引用静态成员，尽管这样做不是一个好主意。如果我们这样做:

Test x = new Test();
Test y = new Test();
x.staticVariable = 10;
y.staticVariable = 20;
System.out.println(x.staticVariable);

然后输出20个变量——只有一个变量，而不是每个实例一个变量。这样写会更清楚:

Test x = new Test();
Test y = new Test();
Test.staticVariable = 10;
Test.staticVariable = 20;
System.out.println(Test.staticVariable);

这使得这种行为更加明显。现代ide通常建议将第二个清单改为第三个清单。

没有理由像下面这样使用内联声明初始化值，因为每个实例都有自己的NUMBER，但总是具有相同的值(不可变并使用文字初始化)。这与所有实例只有一个最终静态变量是一样的。

private final int NUMBER = 10;

因此，如果它不能更改，就没有必要为每个实例提供一个副本。

但是，如果在这样的构造函数中初始化是有意义的:

// No initialization when is declared
private final int number;

public MyClass(int n) {
   // The variable can be assigned in the constructor, but then
   // not modified later.
   number = n;
}

现在，对于MyClass的每个实例，我们可以有一个不同但不可变的number值。

"Static" keyword makes the variable property of the class rather than individual instances of the class. There will be one copy of that variable that is shared amongst all the instances of that class. Any change in the state of the static variable will be reflected across all the instances. Add final to static and we get a variable that has been initialised once and for all at the class loading time and cannot be changed later by any instance of the class. Static final variables need to be initialised at the declaration time else we have compile time error. As far as private instance field is concerned, it refers to the property /state of an object /instance of a class. Each instance /object of the class will have its own copy of instance variable. When instance variable is declared final, it means we cannot change its value for this instance. For this we need to initialise the final variable either at declaration or in the constructor.If its not done in either of them, compile time error will show. Once initialised, if you try to reassign a value you will get a compile time error. Use static final variables where the data will be shared across all the instances of the class and you want the data to be read only.Use instance final variable if you want to represent some data that belongs to a each individual instance of the class but once stored cannot be changed. Usage of static and instance key word depends upon your design needs and what that data represents in the domain. If the data is used across the class instances then there is no need for individual copies/memory references for each object.