# Java - 静态类，块，方法和变量

> 原文： [https://beginnersbook.com/2013/04/java-static-class-block-methods-variables/](https://beginnersbook.com/2013/04/java-static-class-block-methods-variables/)

Static 关键字可以与 class，variable，method 和 block 一起使用。静态成员属于类而不是特定实例，这意味着如果您将成员设为静态，则可以在不使用对象的情况下访问它。我们举一个例子来理解这个：

这里我们有一个静态方法`myMethod()`，我们可以在没有任何对象的情况下调用这个方法，因为当我们将一个成员静态化时它就变成了类级别。如果我们删除 static 关键字并使其成为非静态关键字，那么我们必须创建一个类的对象才能调用它。

> 静态成员对于类的所有实例（对象）是通用的，但非静态成员对于每个类实例是独立的。

```java
class SimpleStaticExample
{
    // This is a static method
    static void myMethod()
    {
        System.out.println("myMethod");
    }

    public static void main(String[] args)
    {
          /* You can see that we are calling this
           * method without creating any object. 
           */
           myMethod();
    }
}
```

输出：

```java
myMethod
```

## 静态块

静态块用于初始化静态变量。当在内存中加载类时，将执行此块。一个类可以有多个静态块，它们将按照它们写入程序的相同顺序执行。

### 示例 1：单个静态块

正如您所看到的，在我们在 main 方法中访问它们之前，两个静态变量都已初始化。

```java
class JavaExample{
   static int num;
   static String mystr;
   static{
      num = 97;
      mystr = "Static keyword in Java";
   }
   public static void main(String args[])
   {
      System.out.println("Value of num: "+num);
      System.out.println("Value of mystr: "+mystr);
   }
}

```

Output:

```java
Value of num: 97
Value of mystr: Static keyword in Java

```

### 示例 2：多个静态块

让我们看看多个静态块如何在 Java 中工作。它们以给定的顺序执行，这意味着第一个静态块在第二个静态块之前执行。这就是原因，第一个块初始化的值被第二个块覆盖。

```java
class JavaExample2{
   static int num;
   static String mystr;
   //First Static block
   static{
      System.out.println("Static Block 1");
      num = 68;
      mystr = "Block1";
  } 
  //Second static block
  static{
      System.out.println("Static Block 2");
      num = 98;
      mystr = "Block2";
  }
  public static void main(String args[])
  {
      System.out.println("Value of num: "+num);
      System.out.println("Value of mystr: "+mystr);
   }
}
```

**输出：**

```java
Static Block 1
Static Block 2
Value of num: 98
Value of mystr: Block2

```

## Java 静态变量

静态变量对于类的所有实例（或对象）是通用的，因为它是类级变量。换句话说，您可以说只创建了一个静态变量副本，并在该类的所有实例之间共享。这些变量的内存分配仅在类加载到内存中时才会发生一次。
几点重点：

*   静态变量也称为类变量。
*   与**非静态变量**不同，这些变量可以直接在静态和非静态方法中访问。

### 示例 1：可以在静态方法中直接访问静态变量

这里我们有一个静态方法`disp()`和两个静态变量`var1`和`var2`。这两个变量都可以在静态方法中直接访问。

```java
class JavaExample3{
  static int var1;
  static String var2;
  //This is a Static Method
  static void disp(){
      System.out.println("Var1 is: "+var1);
      System.out.println("Var2 is: "+var2);
  }
  public static void main(String args[]) 
  {
      disp();
  }
}
```

**Output:**

```java
Var1 is: 0
Var2 is: null

```

### 示例 2：静态变量在类的所有实例之间共享

在此示例中，String 变量是非静态的，整数变量是 Static。正如您在输出中看到的那样，两个对象的非静态变量是不同的，但静态变量在它们之间共享，这就是对象`ob2`对静态变量所做的更改在两个对象中反映的原因。

```java
class JavaExample{
   //Static integer variable
   static int var1=77; 
   //non-static string variable
   String var2;

   public static void main(String args[])
   {
	JavaExample ob1 = new JavaExample();
	JavaExample ob2 = new JavaExample();
	/* static variables can be accessed directly without
	 * any instances. Just to demonstrate that static variables
	 * are shared, I am accessing them using objects so that 
	 * we can check that the changes made to static variables
	 * by one object, reflects when we access them using other
	 * objects
	 */
        //Assigning the value to static variable using object ob1
	ob1.var1=88;
	ob1.var2="I'm Object1";
        /* This will overwrite the value of var1 because var1 has a single 
         * copy shared among both the objects.
         */
        ob2.var1=99;
	ob2.var2="I'm Object2";
	System.out.println("ob1 integer:"+ob1.var1);
	System.out.println("ob1 String:"+ob1.var2);
	System.out.println("ob2 integer:"+ob2.var1);
	System.out.println("ob2 STring:"+ob2.var2);
   }
}
```

Output:

```java
ob1 integer:99
ob1 String:I'm Object1
ob2 integer:99
ob2 STring:I'm Object2

```

有关参考的更多详细信息： [Java - 静态变量](https://beginnersbook.com/2013/05/static-variable/)

## Java 静态方法

静态方法可以在不使用类的对象（实例）的情况下访问类变量（静态变量），但是只能使用对象访问非静态方法和非静态变量。
可以在静态和非静态方法中直接访问静态方法。
**语法：**
静态关键字后跟返回类型，后跟方法名称。

```java
static return_type method_name();
```

### 示例 1：静态方法`main`访问没有对象的静态变量

```java
class JavaExample{
   static int i = 10;
   static String s = "Beginnersbook";
   //This is a static method
   public static void main(String args[]) 
   {
       System.out.println("i:"+i);
       System.out.println("s:"+s);
   }
}
```

**Output:**

```java
i:10
s:Beginnersbook

```

### 示例 2：直接在静态和非静态方法中访问的静态方法

```java
class JavaExample{
  static int i = 100;
  static String s = "Beginnersbook";
  //Static method
  static void display()
  {
     System.out.println("i:"+i);
     System.out.println("i:"+s);
  }

  //non-static method
  void funcn()
  {
      //Static method called in non-static method
      display();
  }
  //static method
  public static void main(String args[])
  {
	  JavaExample obj = new JavaExample();
	  //You need to have object to call this non-static method
	  obj.funcn();

      //Static method called in another static method
      display();
   }
}

```

Output:

```java
i:100
i:Beginnersbook
i:100
i:Beginnersbook

```

阅读更多：[静态方法与 Java 中的非静态方法](https://beginnersbook.com/2013/05/static-vs-non-static-methods/)

## 静态类

只有当它是嵌套类时，才能使**静态**成为类。

1.  嵌套的静态类不需要引用外类
2.  静态类无法访问外部类的非静态成员

我们将在一个例子的帮助下看到这两点：

### 静态类示例

```java
class JavaExample{
   private static String str = "BeginnersBook";

   //Static class
   static class MyNestedClass{
	//non-static method
	public void disp() {

	   /* If you make the str variable of outer class
	    * non-static then you will get compilation error
	    * because: a nested static class cannot access non-
	    * static members of the outer class.
	    */
	   System.out.println(str); 
	}

   }
   public static void main(String args[])
   {
       /* To create instance of nested class we didn't need the outer
	* class instance but for a regular nested class you would need 
	* to create an instance of outer class first
        */
	JavaExample.MyNestedClass obj = new JavaExample.MyNestedClass();
	obj.disp();
   }
}
```

Output:

```java
BeginnersBook
```