"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.

私有静态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

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

考虑下面的例子:

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实例现在将打印三个不同的随机值，因为每个实例都有自己随机生成的常量值。

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

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

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”，我们应该在类中分配一个变量(静态变量属于类)。

假设类永远不会有多个实例，那么哪个实例占用更多内存:

私有静态最终int ID = 250; 或 private final int ID = 250;

我已经理解，静态将引用类类型，在内存中只有一个副本，而非静态将在每个实例变量的新内存位置。但是在内部，如果我们只是比较同一个类的1个实例(即不会创建多个实例)，那么在1个静态final变量所使用的空间方面是否有任何开销?

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