Java基础语法 - 面向对象 - static 关键字

使用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 * */