Java中的Static关键字详解

曾经终败给现在 2022-01-31 15:39 343阅读 0赞

### 文章目录 ###

*   *   *   *  1.Static Variable
             *  2.Static Method
             *  3.Static import Statement
             *  4.Static Block
             *  5.Static Class
             *  6.Summary

#### 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`成员
 *  静态成员(变量和方法)只能在静态方法和静态块中访问。
 *  非静态成员不能在静态方法，块和内部类中访问
 *  一个类可以有多个静态块，按在类定义的顺序执行
 *  一个类只有在作为外部类中的内部类时才可以是静态的
 *  静态导入可用于导入类中所有静态成员，这些成员可在没有任何类引用下引用