Java 静态类、静态方法和静态变量

static 是Java中的一个关键字，我们不能声明普通外层类或者包为静态的。static用于下面四种情况。

1.静态变量

我们可以将类级别的变量声明为static。静态变量是属于类的，而不是属于类创建的对象或实例。因为静态变量被类的所有实例共用，所以非线程安全的。通常静态变量还和关键字final一起用，作为所有对象共用的资源或常量。如果静态变量不是私有的，那么可以通过ClassName.variableName来访问它

    //静态变量的例子
    private static int count;
    public static String str;
    public static final String DB_USER = "myuser"

2.静态方法

类似于静态变量，静态方法也属于类，不属于实例的。静态方法只能访问类的静态变量，或调用类的静态方法。通常静态方法作为工具方法，被其它类使用，而不需要创建类的实例。譬如集合类、Wrapper类(String, Integer等)和工具类(java.util中的类)都有很多静态方法。通常java程序的开始就是一个main()方法，它就是个静态方法。

//静态方法的例子
public static void setCount(int count) {
    if(count > 0)
    StaticExample.count = count;
}

//静态工具方法
public static int addInts(int i, int...js){
    int sum=i;
    for(int x : js) sum+=x;
    return sum;
}

3.静态块

静态块就是类加载器加载对象时，要执行的一组语句。它用于初始化静态变量。通常用于类加载的时候创建静态资源。我们在静态块中不能访问非静态变量。我们可以在一个类中有多个静态块，尽管这么做没什么意义。静态块只会在类加载到内存中的时候执行一次。

static{
    //在类被加载的时候用于初始化资源
    System.out.println("StaticExample static block");
    //仅能访问静态变量和静态方法
    str="Test";
    setCount(2);
}

4.静态类

我们对嵌套类使用static关键字。static不能用于最外层的类。静态的嵌套类和其它外层的类别无二致，嵌套只是为了方便打包。

5.静态类与内部类的区别

5.1 内部类

1. 内部类拥有普通类的所有特性，也拥有类成员变量的特性
2. 内部类可以访问其外部类的成员变量，属性，方法，其它内部类

5.2 静态内部类

1. 只有内部类才能声明为static，也可以说是静态内部类
2. 只有静态内部类才能拥有静态成员，普通内部类只能定义普通成员
3. 静态类跟静态方法一样，只能访问其外部类的静态成员
4. 如果在外部类的静态方法中访问内部类，这时候只能访问静态内部类

/**
 . 外部类，不能声明为 static
 . 
 . @author zhanqi
 . 
 */
public class OuterClass {

    private int ab = 1;
    private static int sab = 2;

    /**
     * 普通内部类
     */
    public class NormalInnerClass {

        // private static int age = 22;
        private int age = 22; // 不能声明为static

        public NormalInnerClass() {
            // 可以访问外部类静态与非静态成员
            System.out.println(ab);
            System.out.println(sab);
        }
    }

    /**
     * 静态内部类
     */
    public static class StaticInnerClass {
        // 定义静态与非静态成员都是可以的
        private static int age = 22;
        private int age2 = 22;

        private void echo() {
            // System.out.println(ab);
            System.out.println(sab);// 只能访问外部类的静态成员
        }
    }
}

5.3 内部类实例化

1. 访问内部类，必须使用：外部类.内部类，OutClass.InnerClass
2. 普通内部类必须绑定在其外部类的实例上
3. 静态内部类可以直接 new

/**
 * 外部类访问内部类
 */
public class OuterClass {

    /**
     * 普通方法
     */
    public void method() {
        StaticInnerClass sic = new StaticInnerClass();
        NormalInnerClass nic = new NormalInnerClass();
    }

    /**
     * Main
     */
    public static void main(String[] args) {
        // 在静态方法中，只能访问静态成员，静态内部类
        // NormalInnerClass nic = new NormalInnerClass();
        StaticInnerClass sic = new StaticInnerClass();
    }
}

/**
 * 其它类访问内部类
 */
class Test {
    public static void main(String[] args) {
        /**
         * 1：其它类访问内部类，必须使用：外部类.内部类，OutClass.InnerClass
         * 2：普通内部类必须绑定在其外部类的实例上
         * 3：静态内部类可以直接 new
         */
        OuterClass.StaticInnerClass sic = new OuterClass.StaticInnerClass();
        // OuterClass.NormalInnerClass n = new OuterClass.NormalInnerClass();

        OuterClass oc = new OuterClass();
        OuterClass.NormalInnerClass nic = oc.new NormalInnerClass();
    }
}

5.4 静态对象

静态对象我们经常使用,但是对静态对象和非静态对象的区别却并不一定那么了解。下表格就是静态对象和非静态对象主要区别。

1. 拥有的对象，静态对象是类共同拥有的 ，而非静态对象是由类单独拥有
2. 内存空间，静态对象内存空间是固定，非静态类对象是附着相关类的分配
3. 分配顺序，先分配静态对象的空间，然后才会分配非静态对象也就是初始化