Language Issues

已经看过了万能的final关键字在Java中的不同用法和效果，其实static关键字的的用处也很广泛。它的用法更多涉及到面向对象设计(Object-Oriented Design)的思想，有时更加让人迷惑。许多是否应该使用static关键字的决定也常常基于工作经验中形成的约束和规范。本文就来帮助大家解锁static的正确使用姿势，写出更加清晰的代码。

为了更好的了解Java程序，就需要了解代码被编译后的样子，所以下边会涉及到javac和javap这些指令的使用，不用担心都是比较简单直接的用法。也需要借助一些反编译(decompile)工具来查看.class文件，这里用到的是JD-GUI。

• 静态变量 Static Variable
• 静态方法 Static Method
• 静态块 Static Block
• 静态嵌套类 Static Nested Class
• 静态引入 Static Import

Static Variable

静态变量(Static Variable)在Java中只有静态成员变量，不同于C++、PHP等，它不允许在方法内定义局部静态变量。静态成员变量也称为类变量，相对的是对象成员变量。这些变量是属于定义的类，而非某个对象实例，但是该类的所有实例都可分享该变量。

用个简单的例子会比较直观一些：
[codesyntax lang=”java” lines=”normal”]

package com.iderzheng.statickeyword;

public class StaticField {
    public static int sField;
    public int mField;

    public void print() {
        System.out.println(
                String.format("%s{sField: %d, mField: %d}", this, sField, mField)
        );
    }

    public static void main(String[] args) {
        StaticField one = new StaticField();
        StaticField two = new StaticField();

        one.sField = 7;
        one.mField = 7;

        two.sField = 21;
        two.mField = 21;

        one.print();
        two.print();

        StaticField.sField = 49;
        // Error: non-static variable mField cannot be referenced from a static context
        // StaticField.mField = 49;
        one.print();
        two.print();
    }
}

[/codesyntax]

编译运行这段代码得到如下结果:

com.iderzheng.statickeyword.StaticField@34469729{sField: 21, mField: 7}
com.iderzheng.statickeyword.StaticField@6d172f8f{sField: 21, mField: 21}
com.iderzheng.statickeyword.StaticField@34469729{sField: 49, mField: 7}
com.iderzheng.statickeyword.StaticField@6d172f8f{sField: 49, mField: 21}

很清楚的看到变量two对sField的修改影响了one中的sField值。而mField在两个对象中是独立互补影响的。也看到可以用类的名字来引用静态变量，这是提倡调用方法，不应该直接用对象变量来引用静态变量，这样做不明确调用的是静态变量，很容易带来副作用。

Static Final Variable

一般在程序中不常定义静态变量，因为静态变量的可被访问和使用的地方比局部变量和对象变量要多，维护起来更加困难。更多时候是跟final结合起来定义常量，对于无法修改的只读变量，就不用担心维护问题了。

对象变量也可以用final修饰定义为常量，只不过每个对象的常量只属于对象自己，而且每个对象都需要分配内存给这些常量。而属于类的静态变量则只需要一份内存甚至无需存储变量的值。所以如果对象变量在每个对象中都是一致的，那么就可以考虑转为静态常量。转成静态常量也能方便地用类名直接进行访问，省去创建多余的中间对象。

Java编译器对于常量会做优化，在引用它们的地方会将它们的值直接嵌入，这样就不需要内存来长期存储这些值，更不要从内存地址中寻找，所以效率要高很多。

还是做一个简单的例子：

[codesyntax lang=”java” lines=”normal”]

package com.iderzheng.statickeyword;

public class StaticFinalFields {

    static final int CONSTANT_INT = 7;
    static final String CONSTANT_STRING = "iderzheng.com";
    static final int[] CONSTANT_ARRAY = { 7, 21, 31 };

    final String name;
    final int constantInt = 21;
    final boolean constantBoolean;

    {
        constantBoolean = true;
    }

    public StaticFinalFields(String name) {
        this.name = name;
    }

    public static void main(String[] args) {
        StaticFinalFields finalFields = new StaticFinalFields("Ider");
        System.out.println(finalFields.name);
        System.out.println(finalFields.constantInt);
        System.out.println(finalFields.constantBoolean);

        System.out.println(CONSTANT_INT);
        System.out.println(CONSTANT_STRING);
        System.out.println(CONSTANT_ARRAY);
    }
}

[/codesyntax]

对于上边的代码，通过javac进行编译后得到StaticFinalFields.class，再讲其通过JD-UI打开，会看到编译后代码的

[codesyntax lang=”java” lines=”normal”]

package com.iderzheng.statickeyword;

import java.io.PrintStream;

public class StaticFinalFields
{
    static final int CONSTANT_INT = 7;
    static final String CONSTANT_STRING = "iderzheng.com";
    static final int[] CONSTANT_ARRAY = { 7, 21, 31 };
    final String name;
    final int constantInt = 21;

    final boolean constantBoolean = true;

    public StaticFinalFields(String paramString)
    {
        this.name = paramString;
    }

    public static void main(String[] paramArrayOfString) {
        StaticFinalFields localStaticFinalFields = new StaticFinalFields("Ider");
        System.out.println(localStaticFinalFields.name);
        localStaticFinalFields.getClass(); System.out.println(21);
        System.out.println(localStaticFinalFields.constantBoolean);

        System.out.println(7);
        System.out.println("iderzheng.com");
        System.out.println(CONSTANT_ARRAY);
    }
}

[/codesyntax]

从编译后的代码可以看出对于原始类型的变量，在用final进行修饰并内嵌初始化后，使用这些变量的地方就直接用这些值进行了替换。虽然也有非static修饰的对象常量被智能优化后直接内嵌，但是为了代码的维护性，依然应该显示地申明成static。

至于对象变量，它们并非真正意义上的常量，对象的创建后的地址也总会不同，而且对象的内容依然可以被修改，所以这些变量加上static final也无法用其值在使用的地方进行替换。

另外还看到通过block进行初始化的对象变量虽然也是常量，但是因为放入了block，编译器觉得它的初始化比较复杂，所以就没有将其引用直接替换。

直接内嵌常量的可以提高运行的效率，但是也有一些弊端：比如项目A中使用了项目B中的静态常量，成功编译后的A会直接使用那些常量；要是B的常量值被人修改了之后只编译了B而没有重新编译A，那A就不会得到新的值。好在现代的编译器都很智能，可以发现这些依赖关系并正确编译。
Read More →