Java中的Static关键字详解

1.Static Variable

使用static关键字声明一个静态变量，格式如下：

访问权限  static 数据类型  变量名

例如：声明一个整型类型的静态变量

public static Integer staticVar;

被static修饰的变量属于类，意味着它在运行时只能有一个变量的副本。

当在类中定义静态变量时，类的每个实例都可以访问该副本。类的单独实例不会有它们自己的本地副本，就像它们对非静态变量所做的那样。

public class JavaStaticExample
{
    public static void main(String[] args)
    {
        DataObject objOne = new DataObject();
        objOne.staticVar = 10;
        objOne.nonStaticVar = 20;
         
        DataObject objTwo = new DataObject();
         
        System.out.println(objTwo.staticVar);       //10
        System.out.println(objTwo.nonStaticVar);    //null
         
        DataObject.staticVar = 30;  //Direct Access
         
        System.out.println(objOne.staticVar);       //30
        System.out.println(objTwo.staticVar);       //30
    }
}
 
class DataObject {
    public static Integer staticVar;
    public Integer nonStaticVar;
}

输出为：

10
null
30
30

如上，将静态变量值更为30，输出的值也都为30.

另外，也可以发现访问静态变量，不需要创建任何实例，这表明static变量属于类范围.

2.Static Method

声明格式：

访问权限  static 返回类型 方法名称

例如，一个Integer类型的public static类型的变量

public static Integer staticVar;

public static Integer getStaticVar(){
    return staticVar;
}

注意：

1. 只能访问静态方法中的静态变量，如果试图访问非静态变量，编译器会报错：

   Cannot make a static reference to the non-static field nonStaticVar“.

2. 静态方法可以通过类引用访问，不需要创建类的实例，尽管也可以使用实例引用进行访问，但是通过类引用访问，但与通过类引用访问相比，两者没有区别。

3. 静态方法属于类范围

public class JavaStaticExample
{
    public static void main(String[] args)
    {
        DataObject.staticVar = 30;  //直接访问
         
        Integer value1 = DataObject.getStaticVar(); //通过类访问
 
        DataObject objOne = new DataObject();
        Integer value2 = objOne.getStaticVar();     //通过类实例访问
         
        System.out.println(value1);
        System.out.println(value2);
    }
}
 
class DataObject
{
    public Integer nonStaticVar;
    public static Integer staticVar;    //静态变量
     
    public static Integer getStaticVar(){
        return staticVar;
    }
}
 
输出：
30
30

3.Static import Statement

普通的导入声明从包中导入类，因此可以在没有包引用的情况下使用它们。类似地，静态导入声明从类中导入静态成员，并允许在没有类引用的情况下使用它们。

静态导入语句也有两种形式:单静态导入和静态随需导入。

单静态导入声明从一个类型导入一个静态成员。静态随需导入声明导入一个类型的所有静态成员。

//Single-static-import declaration:单个导入
import static <<package name>>.<<type name>>.<<static member name>>;
  
//Static-import-on-demand declaration:导入所有
import static <<package name>>.<<type name>>.*;

//静态导入声明
import static java.lang.System.out;
 
public class JavaStaticExample
{
    public static void main(String[] args)
    {
        DataObject.staticVar = 30; 
 
        out.println(DataObject.staticVar);  
    }
}
class DataObject
{
    public static Integer staticVar;    
}

输出：
30

4.Static Block

静态块是类初始化的一部分，用static关键字封装

public class Main {
      
    //static initializer
    static {
        System.out.println("Inside static initializer");
    }  
}

静态块在类装入内存时执行，一个类可以有多个静态块，这些静态块按照在类中的定义按顺序执行。

import static java.lang.System.out;
 
class DataObject
{
    public Integer nonStaticVar;
    public static Integer staticVar;    //static variable
     
    //It will be executed first
    static {
        staticVar = 40;
        //nonStaticVar = 20;    //无法操作非静态成员
    }
     
    //It will be executed second
    static {
        out.println(staticVar);
    }
}
 
输出：
40

5.Static Class

在Java中，可以将静态类作为内部类。与其他静态成员一样，嵌套的类属于类作用域，因此可以在没有外部类对象的情况下访问内部静态类。

public class JavaStaticExample
{
    public static void main(String[] args)
    {
        //Static inner class example
        System.out.println( DataObject.StaticInnerClas.innerStaticVar );
    }
}
class DataObject
{
    public Integer nonStaticVar;
    public static Integer staticVar;    //static variable
     
    static class StaticInnerClas {
        Integer innerNonStaticVar = 60;
        static Integer innerStaticVar = 70;     //static variable inside inner class
    }
}

静态内部类不能访问外部类的非静态成员。它只能访问外部类的静态成员。

public class JavaStaticExample
{
    public static void main(String[] args)
    {
        DataObject.StaticInnerClas.accessOuterClass();
    }
}
class DataObject
{
    public Integer nonStaticVar;
    public static Integer staticVar;    //static variable
         
    static {
        staticVar = 40;
        //nonStaticVar = 20;    //Not possible to access non-static members
    }
 
    public static Integer getStaticVar(){
        return staticVar;
    }
     
    static class StaticInnerClas
    {  
        public static void accessOuterClass()
        {
            System.out.println(DataObject.staticVar);       //static variable of outer class
            System.out.println(DataObject.getStaticVar());  //static method of outer class
        }
    }
}

输出：
40

6.Summary

关于static关键字的总结如下：

• static成员属于类，不需要创建类实例就可以访问static成员
• 静态成员(变量和方法)只能在静态方法和静态块中访问。
• 非静态成员不能在静态方法，块和内部类中访问
• 一个类可以有多个静态块，按在类定义的顺序执行
• 一个类只有在作为外部类中的内部类时才可以是静态的
• 静态导入可用于导入类中所有静态成员，这些成员可在没有任何类引用下引用