从我所做的测试来看，静态最终变量与最终(非静态)变量是不一样的!最终(非静态)变量可以因对象而异!!但前提是在构造函数内部进行初始化!(如果它没有从构造函数初始化，那么它只是浪费内存，因为它为每个创建的不能更改的对象创建最终变量。)

例如:

class A
{
    final int f;
    static final int sf = 5;

    A(int num)
    {
        this.f = num;
    }

    void show()
    {
        System.out.printf("About Object: %s\n Final: %d\n Static Final: %d\n\n", this.toString(), this.f, sf);
    }

    public static void main(String[] args)
    {
        A ob1 = new A(14);
        ob1.show();

        A ob2 = new A(21);
        ob2.show();

    }
}

屏幕上显示的是:

关于对象:A@addbf1 最后:14 静态决赛:5分

关于对象:A@530daa 最后:21 静态决赛:5分

匿名的一年级IT学生，希腊

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

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

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

正如Jon已经说过的，静态变量，也称为类变量，是跨类实例存在的变量。

我在这里找到了一个例子:

public class StaticVariable
{
  static int noOfInstances;
  StaticVariable()
  {
    noOfInstances++;
  }
  public static void main(String[] args)
  {
    StaticVariable sv1 = new StaticVariable();
    System.out.println("No. of instances for sv1 : " + sv1.noOfInstances);

    StaticVariable sv2 = new StaticVariable();
    System.out.println("No. of instances for sv1 : "  + sv1.noOfInstances);
    System.out.println("No. of instances for st2 : "  + sv2.noOfInstances);

    StaticVariable sv3 = new StaticVariable();
    System.out.println("No. of instances for sv1 : "  + sv1.noOfInstances);
    System.out.println("No. of instances for sv2 : "  + sv2.noOfInstances);
    System.out.println("No. of instances for sv3 : "  + sv3.noOfInstances);
  }
}

程序输出如下:

正如我们在这个例子中看到的，每个对象都有自己的类变量副本。

C:\java>java StaticVariable
No. of instances for sv1 : 1
No. of instances for sv1 : 2
No. of instances for st2 : 2
No. of instances for sv1 : 3
No. of instances for sv2 : 3
No. of instances for sv3 : 3

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

    private final int         value             = 10;
    private static final int  valueStatic       = 20;
    private final File        valueObject       = new File("");
    private static final File valueObjectStatic = new File("");

    public void printAddresses() {


        System.out.println("final int address " +
                ObjectUtils.identityToString(value));
        System.out.println("final static int address " +
                ObjectUtils.identityToString(valueStatic));
        System.out.println("final file address " + 
                ObjectUtils.identityToString(valueObject));
        System.out.println("final static file address " + 
                ObjectUtils.identityToString(valueObjectStatic));
    }


    public static void main(final String args[]) {


        final ConstTest firstObj = new ConstTest();
        final ConstTest sndObj = new ConstTest();

        firstObj.printAdresses();
        sndObj.printAdresses();
    }

}

第一个对象的结果:

final int address java.lang.Integer@6d9efb05
final static int address java.lang.Integer@60723d7c
final file address java.io.File@6c22c95b
final static file address java.io.File@5fd1acd3

第二个对象的结果:

final int address java.lang.Integer@6d9efb05
final static int address java.lang.Integer@60723d7c
final file address java.io.File@3ea981ca
final static file address java.io.File@5fd1acd3

结论:

正如我认为java使原始类型和其他类型之间的区别。Java中的基本类型总是“缓存”的，对于字符串字面量也是如此(不是新的String对象)，所以静态和非静态成员没有区别。

然而，如果非静态成员不是基元类型的实例，则存在内存复制。

将valueStatic的值更改为10甚至可以更进一步，因为Java将为两个int变量提供相同的地址。

这可能会有所帮助

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.");
    }
}