Java中的static关键字

静态变量静态方法

static关键字基本用法：

1.被static修饰的变量为静态变量，通过类名.变量名可以直接访问。

2.被static修饰的方法为静态方法，通过类名.方法名可以直接访问。

静态变量和静态方法属于类自身，被类对象实例共享。

有些人容易混淆的一个问题：静态方法能不能引用非静态资源？静态方法里面能不能引用静态资源？非静态方法里面能不能引用静态资源？比如就以这段代码为例，是否有错？

public class StaticTest {
    
    private int i;

    public static void main(String[] args) {
        //i = 1;    //编译报错，不能引用非静态的变量
    }

}

 很明显有编译错误，静态方法不能引用非静态的变量。

静态资源属于类，但是是独立于类存在的。从JVM的类加载机制的角度讲，静态资源是类初始化的时候加载的，而非静态资源是类new的时候加载的。类的初始化早于类的new，比如Class.forName(“xxx”)方法，就是初始化了一个类，但是并没有new它，只是加载这个类的静态资源罢了。所以对于静态资源来说，它是不可能知道一个类中有哪些非静态资源的；但是对于非静态资源来说就不一样了，由于它是new出来之后产生的，因此属于类的这些东西它都能认识。所以上面的几个问题答案就很明确了：

1、静态方法能不能引用非静态资源？不能，new的时候才会产生的东西，对于初始化后就存在的静态资源来说，根本不认识它。

2、静态方法里面能不能引用静态资源？可以，因为都是类初始化的时候加载的，大家相互都认识。

3、非静态方法里面能不能引用静态资源？可以，非静态方法就是实例方法，那是new之后才产生的，那么属于类的内容它都认识。

 

静态代码块

public class A
{
    private static int a = B();
    
    static
    {
        System.out.println("Enter A.static block");
    }
    
    public static void main(String[] args)
    {
        new A();
    }
    
    public static int B()
    {
        System.out.println("Enter A.B()");
        return 1;
    }
}

 这段代码运行结果为：

Enter A.B()
Enter A.static block

 由此得第一个结论：静态资源的加载顺序是严格按照静态资源的定义顺序来加载的。这和周志明老师《深入理解Java虚拟机：JVM高级特性与最佳实践》中类初始化中的说法“<clinit>()方法是由编译器自动收集类中所有类变量的赋值动作和静态语句块（static{}块）中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序所决定的”是一致的。

再看一个例子：

public class A
{
    static
    {
        c = 3;
        //System.out.println(c);		//编译报错，不能使用，未定义
    }
    
    private static int c;
}

 从这个例子得出第二个结论：静态代码块对于定义在它之后的静态变量，可以赋值，但是不能访问。PS：一般我们也不会这样写代码。

最后一个小例子：

public class A
{
    static
    {
        System.out.println("A.static block");
    }
    
    public A()
    {
        System.out.println("A.constructor()");
    }
}

 

public class B extends A
{
    static 
    {
        System.out.println("B.static block");
    }
    
    public B()
    {
        System.out.println("B.constructor()");
    }
    
    public static void main(String[] args)
    {
        new B();
        new B();
    }
}

 执行这段代码，输出结果为：

A.static block
B.static block
A.constructor()
B.constructor()
A.constructor()
B.constructor()

 这个比较好理解，这个例子得出第三个结论：静态代码块是严格按照父类静态代码块->子类静态代码块的顺序加载的，且只加载一次。

 

static修饰类

static修饰的类为静态内部类，比如单例设计模式，有一种方式就可以用静态内部类来实现。

 

import static

这个比较冷门，一般用于导入静态常量或方法的包。

 

 

 

转自：http://www.cnblogs.com/xrq730/p/4820992.html

<audio controls="controls" style="display: none;"></audio>