Java编程之java static关键字

一、java中static关键字

java中的static关键字可以应用于变量、方法、块、导入和内部类。在本教程中，我们将了解在这些地方使用static关键字的效果。

本文将要讲解的内容目录:

• Static 变量的使用讲解
• Static 方法的使用讲解
• Static 导入声明使用讲解
• Static 块的使用讲解
• Static 类的使用讲解
• static关键字使用总结

二、static变量

要声明一个static变量，请在变量声明中使用static关键字。static变量的语法是:

ACCESS_MODIFER static DATA_TYPE VARNAME;

例如，用这种方式声明整数类型的公共静态变量。

public static Integer staticVar;

静态变量最重要的一点是它们属于类级别。这意味着在运行时只能有一个变量的副本。当在类定义中定义静态变量时，类的每个实例都可以访问该单一副本。单独的类实例不会有它们自己的本地副本，就像它们对非静态变量一样。

让我们来了解一个例子:

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。

另一件您应该注意到的是，我们如何能够使用它的类名来访问静态变量，即dataobject . staticvar。我们不需要创建任何实例来访问静态变量。它清楚地表明静态变量属于类范围。

三、static方法

要声明静态方法，请在方法声明中使用静态关键字。静态方法的语法是:

ACCESS_MODIFER static RETURN_TYPE METHOD_NAME;

例如，用这种方式声明整数类型的公共静态变量。

public static Integer getStaticVar(){
    return staticVar;
}

要记住的一些事项。

1. 您只能在静态方法中访问静态变量。如果您尝试访问任何非静态变量，将生成的编译器错误信息“无法对非静态字段非静态变量进行静态引用”。
2. 静态方法可以通过它的类引用来访问，并且不需要创建类的实例。虽然您也可以使用实例引用，但是与通过类引用的访问相比，它不会有任何不同。
3. 静态方法也属于类级范围。

public class JavaStaticExample 
{
    public static void main(String[] args) 
    {
        DataObject.staticVar = 30;  //Direct Access
         
        Integer value1 = DataObject.getStaticVar(); //access with class reference
 
        DataObject objOne = new DataObject();
        Integer value2 = objOne.getStaticVar();     //access with instance reference
         
        System.out.println(value1);
        System.out.println(value2);
    }
}
 
class DataObject 
{
    public Integer nonStaticVar;
    public static Integer staticVar;    //static variable
     
    public static Integer getStaticVar(){
        return staticVar;
    }
}

输出内容:

30
30

四、static Import 声明

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

    静态导入声明也有两种类型:单静态导入和静态导入。单静态导入声明从类型中导入一个静态成员。静态输入-点播声明导入了类型的所有静态成员。
 

//Single-static-import declaration:
  
import static <<package name>>.<<type name>>.<<static member name>>;
  
//Static-import-on-demand declaration:
  
import static <<package name>>.<<type name>>.*;

例如, System.out is

//Static import statement
import static java.lang.System.out;
 
public class JavaStaticExample 
{
    public static void main(String[] args) 
    {
        DataObject.staticVar = 30;  
 
        out.println(DataObject.staticVar);  //Static import statement example
    }
}
class DataObject 
{
    public static Integer staticVar;    //static variable
}

输出：

30

五、Static 块

静态块是类初始化代码的一部分，它用静态关键字包装。一般的语法是:

static {
    //initialize static members of class
}

当类装入内存时，将执行静态块。一个类可以有多个静态块，并且它们将以相同的顺序执行，它们在类定义中出现。

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;    //Not possible to access non-static members
    }
     
    //It will be executed second
    static {
        out.println(staticVar);
    }
}

输出:

40

六、static 类

在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) 
    {
        //Static inner class example
        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

七、总结

让我们总结一下java中静态使用的所有内容。

1. 静态成员属于类。不需要创建类实例来访问静态成员。
2. 静态成员(变量和方法)只能在静态方法和静态块中访问。
3. 不能在静态方法、块和内部类中访问非静态成员。
4. 一个类可以有多个静态块，它们将按照类定义的顺序执行。
5. 只有当类声明为内部类内部类时，类才能是静态的。
6. 静态导入可用于从类导入所有的静态成员。这些成员可以被引用，没有任何类引用。

Java编程 static关键字

http://blog.xqlee.com/article/218.html