static的用法

修饰变量

举例：

private static String s1;
public static int i = 1;
public static String s2;

作用：

1. 静态变量只有在类被初次加载时初始化（非静态变量在创建对象时初始化）；
2. 静态变量的值被JVM分配在内存堆上；
3. 静态变量可以使用类名引用，也可以使用对象引用；

修饰方法

举例：

public static printString(String s){
	System.out.println(s);
}

作用：

1. 静态方法不允许被重写；
2. 不允许使用this和super（因为不依赖对象）；
3. 静态方法中不允许直接访问非静态变量和非静态方法（因为不依赖对象）；
4. 静态方法可以使用类名引用，也可以使用对象引用，因此如果不想创建对象，可以把方法定义成静态方法；

修饰代码块

public class BaseTest {

    static{
        System.out.println("B");
    }

    public static void main(String[] args) throws Exception{
        System.out.println("A");
    }
}

作用：
优化性能（因为静态代码块的加载优先级高于构造代码和构造方法，且仅在类初次加载时初始化。上述代码先输出B，后输出A）

修饰类

举例：

public class OutClassTest {
    static int a;
    int b;

    public static void test() {
        System.out.println("outer class static function");
    }

    public static void main(String[] args) {
        // new一个外部类
        OutClassTest oc1 = new OutClassTest();
        // 通过外部类的对象new一个非静态的内部类
        OutClassTest.InnerClass no_static_inner = oc1.new InnerClass();
        // 调用非静态内部类的方法
        System.out.println(no_static_inner.getKey());

        // 调用静态内部类的静态变量
        System.out.println(OutClassTest.InnerStaticClass.static_value);
        // 不依赖于外部类实例,直接实例化内部静态类
        OutClassTest.InnerStaticClass inner = new OutClassTest.InnerStaticClass();
        // 调用静态内部类的非静态方法
        System.out.println(inner.getValue());
        // 调用内部静态类的静态方法
        System.out.println(OutClassTest.InnerStaticClass.getMessage());
    }

    private class InnerClass {
        // 只有在静态内部类中才能够声明或定义静态成员
        // private static String tt = "0";
        private int flag = 0;

        public InnerClass() {
            // 三.非静态内部类的非静态成员可以访问外部类的非静态变量和静态变量
            System.out.println("InnerClass create a:" + a);
            System.out.println("InnerClass create b:" + b);
            System.out.println("InnerClass create flag:" + flag);
            //
            System.out.println("InnerClass call outer static function");
            // 调用外部类的静态方法
            test();
        }

        public  String getKey() {
            return "no-static-inner";
        }
    }

    private static class InnerStaticClass {
        // 静态内部类可以有静态成员，而非静态内部类则不能有静态成员。
        private static String static_value = "0";

        private int flag = 0;

        public InnerStaticClass() {
            System.out.println("InnerClass create a:" + a);
            // 静态内部类不能够访问外部类的非静态成员
            // System.out.println("InnerClass create b:" + b);
            System.out.println("InnerStaticClass flag is " + flag);
            System.out.println("InnerStaticClass tt is " + static_value);
        }

        public int getValue() {
            // 静态内部类访问外部类的静态方法
            test();
            return 1;
        }

        public static String getMessage() {
            return "static-inner";
        }
    }

    public OutClassTest() {
        // new一个非静态的内部类
        InnerClass ic = new InnerClass();
        System.out.println("OuterClass create");
    }

}

作用：

1. 可以直接使用外部类引用内部类生成实例；
2. 可以直接使用外部类引用内部静态类引用内部类的变量和方法；
3. 只能在内部静态类中定义静态变量和静态方法，内部普通类不能定义静态变量和静态方法；
4. 内部静态类不可以使用外部非静态变量和非静态方法，只可以使用外部类的静态变量和静态方法；

修饰导入包

举例：

import static java.lang.System.out;

import static java.lang.Integer.*;


public class TestStaticImport {

	public static void main(String[] args) {
	
		out.println(MAX_VALUE);
		
		out.println(toHexString(42));
		
	}

}

作用：
导入包中的静态变量或方法，可以减少重复代码输入量；

其它

static不能用于修饰局部变量（java规定）