Java static关键字 – 变量、方法、块、类和导入语句

文
章
目
录

• 1. 静态变量
• 2. 静态方法
• 3. 静态导入语句
• 4.静态代码块
• 5. 静态内部类
• 六、总结

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

1. 静态变量

要声明变量为静态，请在变量声明中使用static关键字。静态变量语法为：

访问修饰符 static 数据类型 变量名；

例如，Integer类型的公共静态变量就是这样声明的。

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变量。它清楚地表明静态变量属于类范围。

2. 静态方法

要声明静态方法，请static在方法声明中使用关键字。静态方法语法为：

访问修饰符 static  返回值类型 方法名；

例如，返回Integer类型的公共静态变量就是这样声明的。

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;  //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

3. 静态导入语句

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

静态导入语句也有两种形式：单个静态导入和静态导入所有成员。单个静态导入声明从一个类型中导入一个静态成员。静态导入所有成员声明导入一个类型的所有静态成员。

//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

//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

4.静态代码块

静态代码块是类初始化代码的一部分，用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;  //Not possible to access non-static members
  }
   
  //It will be executed second
  static {
    out.println(staticVar);
  }
}

输出：

40

5. 静态内部类

在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中关于static关键字的用法

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

归属教程 Java基础教程

文章目录 前言  第1章 Java语言基础 第2章 流程控制语句 第3章 面向对象编程 第4章 Java 字符 […]