由于类中的变量在同一个命令中声明为final和初始化， 绝对没有理由不将其声明为静态，因为无论实例如何，它都具有相同的值。因此，所有实例都可以为一个值共享相同的内存地址，这样就不需要为每个实例创建一个新变量，并通过共享一个公共地址来节省内存，从而节省了处理时间。

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

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

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值。

非常少，而且是静态的

因为它们都是常数，所以区别不大。对于大多数类数据对象，静态意味着与类本身相关联的东西，无论用new创建了多少个对象，都只有一个副本。

因为它是一个常量，所以它实际上可能不会存储在类中或实例中，但是编译器仍然不会让你从静态方法访问实例对象，即使它知道它们会是什么。如果您不使反射API成为静态的，那么它的存在也可能需要一些无意义的工作。

这可能会有所帮助

public class LengthDemo {
public static void main(String[] args) {
    Rectangle box = new Rectangle();
    System.out.println("Sending the value 10.0 "
            + "to the setLength method.");
    box.setLength(10.0);
    System.out.println("Done.");
    }
}

静态变量属于类(这意味着所有对象共享该变量)。非静态变量属于每个对象。

public class ExperimentFinal {

private final int a;
private static final int b = 999; 

public ExperimentFinal(int a) {
    super();
    this.a = a;
}
public int getA() {
    return a;
}
public int getB() {
    return b;
}
public void print(int a, int b) {
    System.out.println("final int: " + a + " \nstatic final int: " + b);
}
public static void main(String[] args) {
    ExperimentFinal test = new ExperimentFinal(9);
    test.print(test.getA(), test.getB());
} }

正如你可以看到上面的例子，对于“final int”，我们可以为类的每个实例(对象)分配变量，然而对于“static final int”，我们应该在类中分配一个变量(静态变量属于类)。

私有静态final将被视为常量，并且只能在该类中访问该常量。因为包含了关键字static，所以该类的所有对象的值都是常量。

私有最终变量值将像每个对象的常量。

您可以参考java.lang.String或查看下面的示例。

public final class Foo
{

    private final int i;
    private static final int j=20;

    public Foo(int val){
        this.i=val;
    }

    public static void main(String[] args) {
        Foo foo1= new Foo(10);

        Foo foo2= new Foo(40);

        System.out.println(foo1.i);
        System.out.println(foo2.i);
        System.out.println(check.j);
    }
}

/ /输出:

10
40
20