# Java 静态 – 变量，方法，块，类和导入语句

> 原文： [https://howtodoinjava.com/java/basics/java-static-keyword/](https://howtodoinjava.com/java/basics/java-static-keyword/)

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

```java
Table of Contents

1\. Static Variable
2\. Static Method
3\. Static Import Statement
4\. Static Block
5\. Static Class
6\. Summary
```

## 1\. 静态变量

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

```java
ACCESS_MODIFER static DATA_TYPE VARNAME;
```

例如，以这种方式语句`Integer`类型的公共静态变量。

```java
public static Integer staticVar;
```

关于静态变量的最重要的事情是它们属于**类级别**。 这意味着在运行时中只能有**变量的一个副本**。

在类定义中定义静态变量时，类的每个实例都可以访问该单个副本。 类的单独实例不会像非静态变量一样拥有自己的本地副本。

```java
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;
}

Output:

10
null
30
30

```

注意我们如何将值更改为 30，并且两个对象现在都看到更新后的值 30。

您应该已经注意到的另一件事是，我们如何能够**使用其类名**即`DataObject.staticVar`访问静态变量。 我们无需创建任何实例即可访问`static`变量。 它清楚地表明**静态变量属于类范围**。

## 2\. 静态方法

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

```java
ACCESS_MODIFER static RETURN_TYPE METHOD_NAME;
```

例如，以这种方式声明了一个`Integer`类型的公共静态变量。

```java
public static Integer staticVar;

public static Integer getStaticVar(){

	return staticVar;
}
```

几件事要记住。

1.  您只能*访问静态方法*中的静态变量。 如果您尝试访问任何非静态变量，则会生成编译器错误，并显示消息“*无法对非静态字段`nonStaticVar`进行静态引用*”。
2.  静态方法可以通过其类引用进行访问，而无需创建类的实例。 尽管您也可以使用实例引用进行访问，但是与通过类引用进行访问相比，它没有任何区别。
3.  静态方法也属于类级别范围。

```java
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;
	}
}

Output:

30
30

```

## 3\. 静态导入语句

普通的导入语句从包中导入类，因此可以在不引用包的情况下使用它们。 同样，**静态导入**语句*从类*导入静态成员，并允许在没有类引用的情况下使用它们。

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

```java
//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`是

```java
//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
}

Output:

30

```

> 阅读更多： [Java 中的静态导入语句](//howtodoinjava.com/java/basics/static-import-declarations-in-java/)

## 4\. 静态块

静态块是[类初始化](https://howtodoinjava.com/java/basics/how-to-create-a-class-in-java/
)代码的一部分，并用`static`关键字包装。

```java
public class Main {

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

```

当将类加载到内存中时，将执行静态块。 一个类可以具有多个静态块，并且这些静态块将按照它们在类定义中出现的相同顺序执行。

```java
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);
	}
}

Output:

40

```

## 5\. 静态类

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

```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
	}
}

```

请注意，*静态内部类*无法访问外部类的非静态成员。 它只能访问外部类的静态成员。

```java
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
		}
	}
}

Output:

40

```

## 6\. 总结

让我们总结一下有关 Java 中`static keyword`使用情况的所有信息。

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

学习愉快！

参考文献：

[类成员](https://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html)

[嵌套类](https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html)