使用static關鍵字修飾的變數、常量和方法分別被稱作靜態變數、靜態常量和靜態方法，也被稱作類的靜態成員

靜態變數

使用static修飾過的類變數稱為靜態變數

該變數需要使用類名.變數名進行呼叫，不能使用物件名/this進行呼叫

在類方法中不能定義與靜態變數同名的區域性變數

 1 package mingri.chapter_6;
 2 
 3 public class Pool {
 4 
 5     public static int water = 0;    // 定義一個靜態變數
 6 
 7     public void outlet() {
 8         //
 
 String water = "";   // 在類方法中，不能定義與靜態變數同名的變數名
 9         if (water >= 2) {       // 在類方法中不能使用 this.water 進行呼叫，只能使用變數名進行呼叫
10             water -= 2;
11         } else {
12             water = 0;
13         }
14     }
15 
16     public void inlet() {
17         water += 3;
18     }
19 
20     public static
 
 void main(String[] args) {
21         Pool pool = new Pool();
22         System.out.println("水池的水量：" + Pool.water);  // 只能通過類名.靜態變數名進行訪問
23 
24         pool.inlet();
25         pool.inlet();
26 
27         System.out.println("水池的水量：" + Pool.water);
28         System.out.println("水池放水一次");
29         pool.outlet();
 
30         System.out.println("水池的水量：" + Pool.water);
31     }
32 }

靜態方法

靜態方法與靜態變數類似，使用類名.靜態方法名即可呼叫

 1 package mingri.chapter_6;
 2 
 3 public class Pool2 {
 4 
 5     // 定義靜態變數
 6     public static int water = 0;
 7 
 8     // 定義靜態方法
 9     public static void outlet() {
10         if (water > 2) {
11             water -= 2;
12         } else {
13             water = 0;
14         }
15     }
16 
17     // 定義靜態方法
18     public static void inlet() {
19         water += 3;
20     }
21 
22     public static void main(String[] args) {
23         System.out.println("水池的水量：" + Pool2.water);     // 呼叫靜態變數
24         System.out.println("水池注水兩次。");
25 
26         Pool2.inlet();      // 呼叫靜態方法
27         Pool2.inlet();
28 
29         System.out.println("水池的水量：" + Pool2.water);    // 呼叫靜態變數
30         System.out.println("水池放水一次。");
31 
32         Pool2.outlet();     // 呼叫靜態方法
33 
34         System.out.println("水池的水量：" + Pool2.water);     // 呼叫靜態變數
35     }
36 }

靜態程式碼塊

在類的成員方法之外，用static修飾程式碼區域可以稱之為靜態程式碼塊。定義一塊靜態程式碼塊，可以完成類的初始化操作，在類宣告時就會執行

語法如下：

 1 package mingri.chapter_6;
 2 
 3 public class StaticTest {
 4 
 5     // 靜態程式碼塊
 6     static {
 7         System.out.println("靜態程式碼塊");
 8     }
 9 
10     public static void main(String[] args) {
11         StaticTest st;
12         System.out.println("main主方法");
13     }
14 }

程式碼塊的執行順序

 1 package mingri.chapter_6;
 2 
 3 public class StaticTest {
 4 
 5     static String name;
 6 
 7     // 靜態程式碼塊
 8     static {
 9         System.out.println(name + "靜態程式碼塊");
10     }
11 
12     public StaticTest(String str){
13         name = str;
14         System.out.println(name + "構造方法");
15 
16     }
17 
18     public void method() {
19         System.out.println(name + "成員方法");
20     }
21 
22     public static void main(String[] args) {
23         StaticTest s1;      // 宣告變數的時候就已經執行靜態程式碼塊了
24         StaticTest s2 = new StaticTest("s2");
25         StaticTest s3 = new StaticTest("s3");
26         s3.method();
27         System.out.println("main主方法");
28     }
29 }
30 
31 /*
32 * 輸出結果
33     null靜態程式碼塊
34     s2構造方法
35     s3構造方法
36     s3成員方法
37     main主方法
38 * */