根据Jon的回答，如果你使用静态韵母，它将表现为一种“定义”。一旦你编译了使用它的类，它将在编译后的.class文件中被烧毁。 在这里查看我的帖子。

对于你的主要目标:如果你没有在类的不同实例中使用不同的NUMBER，我建议使用final和static。 (您只需要记住，在不考虑像我的案例研究所描述的那样可能出现的问题的情况下，不要复制已编译的类文件。大多数情况下不会发生这种情况，别担心:))

为了向你展示如何在实例中使用不同的值，检查下面的代码:

public class JustFinalAttr {
  public final int Number;

  public JustFinalAttr(int a){
    Number=a;
  }
}

...System.out.println(new JustFinalAttr(4).Number);

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

以下是我的观点:

final           String CENT_1 = new Random().nextInt(2) == 0 ? "HEADS" : "TAILS";
final   static  String CENT_2 = new Random().nextInt(2) == 0 ? "HEADS" : "TAILS";

例子:

package test;

public class Test {

    final long OBJECT_ID = new Random().nextLong();
    final static long CLASSS_ID = new Random().nextLong();

    public static void main(String[] args) {
        Test[] test = new Test[5];
        for (int i = 0; i < test.length; i++){
            test[i] = new Test();
            System.out.println("Class id: "+test[i].CLASSS_ID);//<- Always the same value
            System.out.println("Object id: "+test[i].OBJECT_ID);//<- Always different
        }
    }
}

关键是变量和函数可以返回不同的值。因此，最终变量可以被赋予不同的值。

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

private static final int NUMBER = 10;

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

非常少，而且是静态的

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

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

这是另一个简单的例子来理解静态，静态final, final变量的用法。代码注释有适当的解释。

public class City {

    // base price that is always same for all objects[For all cities].
    private static double iphone_base_price = 10000;

    // this is total price = iphone_base_price+iphone_diff;
    private double iphone_citi_price;

    // extra price added to iphone_base_price. It is constant per city. Every
    // city has its own difference defined,
    private final double iphone_diff;

    private String cityName = "";

    // static final will be accessible everywhere within the class but cant be
    // changed once initialized.
    private static final String countryName = "India";

    public City(String cityName, double iphone_diff) {
        super();
        this.iphone_diff = iphone_diff;
        iphone_citi_price = iphone_base_price + iphone_diff;
        this.cityName = cityName;

    }

    /**
     * get phone price
     * 
     * @return
     */
    private double getPrice() {

        return iphone_citi_price;
    }

    /**
     * Get city name
     * 
     * @return
     */
    private String getCityName() {

        return cityName;
    }

    public static void main(String[] args) {

        // 300 is the
        City newyork = new City("Newyork", 300);
        System.out.println(newyork.getPrice() + "  " + newyork.getCityName());

        City california = new City("California", 800);
        System.out.println(california.getPrice() + "  " + california.getCityName());

        // We cant write below statement as a final variable can not be
        // reassigned
        // california.iphone_diff=1000; //************************

        // base price is defined for a class and not per instances.
        // For any number of object creation, static variable's value would be the same
        // for all instances until and unless changed.
        // Also it is accessible anywhere inside a class.
        iphone_base_price = 9000;

        City delhi = new City("delhi", 400);
        System.out.println(delhi.getPrice() + "  " + delhi.getCityName());

        City moscow = new City("delhi", 500);
        System.out.println(moscow.getPrice() + "  " + moscow.getCityName());

        // Here countryName is accessible as it is static but we can not change it as it is final as well. 
        //Something are meant to be accessible with no permission to modify it. 
        //Try un-commenting below statements
        System.out.println(countryName);

        // countryName="INDIA";
        // System.out.println(countryName);

    }

}