携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第29天，点击查看活动详情

01.面向对象_static关键字_概念

1.场景：假如我们做一个项目，要经常计算圆的面积，这个项目中包含了很多的模块，每个模块包含很多的类，每个类中都可能去多次的计算圆的面积，计算圆的面积需要用到一个PI值，现在公司要求整个项目统一这个PI值的精度，取值为：3.14159。

2.定义一个类：

class Const{
    public static double PI = 3.14159;//意味着：只产生一个存储空间，被存储在方法区的"静态存储区"中。
}

其它类使用时可以来取：

class Student {
    public void show(){
        Const c = new Const();
        double pi = c.PI;
        .....
    }
}
class Teacher{
    public void teach(){
        Const c = new Const();
        double pi = c.PI;
        .....

    }
}

3.对于PI变量，无论产生多少个Const对象，PI变量空间只有一个，被多个对象共享。

02.面向对象_static关键字_使用位置_特点

1.static关键字的使用位置：

1).修饰成员变量：表示静态变量，只有一个存储空间，被多个对象共享；
```
  class Const{
      public static double PI = 3.14159;
  }
  
```

2).修饰成员方法：表示静态方法，作为工具性方法，可以通过类名直接调用，方便使用；

  class ArrayTools{
      //求int[]数组内元素的和
      public static int sum(int[] array){//静态方法，后期可以通过"类名"直接访问，使用方便
      }
      //求int[]数组内元素的最大值
      public static int getMax(int[] array){
      }
  }

03.面向对象_static关键字_static成员的访问方式

1.静态成员的访问方式：

1).可以通过"对象名"调用(但是很少用):

  class Const{
      public static double PI = 3.14;
  }
  class ArrayTools{
      public static int sum(int[] array){
      }
  }
  main(){
      Const c = new Const();
      System.out.println(c.PI);

      int[] arr = {1,2,3,4};
      ArrayTools at = new ArrayTools();
      System.out.println("数组元素的和是：" + at.sum(arr));
  }

2).可以通过"类名"访问(常用):

  main(){
      System.out.println(Const.PI);//OK的

      int[] arr = {1,2,43,254,324};
      System.out.println("数组元素的和是：" + ArrayTools.sum(arr));//OK的
  }

2.静态成员的初始化时机：

1).静态成员的初始化：是在第一次使用这个类时；在创建对象之前。

  class Const{
      public static double PI = 3.14159;
      public static String schoolName = "清华";
  }
 --------------------------------------------------------------------
  main(){
      //1.第一次创建对象;

      //2.第一次访问这个类中的静态属性、静态方法时
      System.out.println(Const.PI);//如果是第一次使用Const类，会先将这个类中所有的静态成员分配空间
  }

2）

class Const{
        public static double PI = 3.14159;
        public String name = "小明";

        public static void show(){
            System.out.println(PI);
            System.out.println(name);
        }
       }
       A).静态成员只能直接访问静态成员；(静态成员先产生)
       B).普通成员可以直接访问静态成员、普通成员。

3).一个例子：

  class A{
      public A(){
          System.out.println("a");
      }
  }
  class Student{
      public static A a = new A();
      public static double PI = 3.14;
      public Student(){
          System.out.println("b");
      }
  }
  main(){
      System.out.println(Student.PI);//会为：成员变量:PI和a分配空间，也会为show()方法分配空间
  }

4).在静态方法内：不能使用this和super关键字；因为在静态方法被分配空间时，还没有产生对象，所以不能使用this和super关键字。

04.面向对象_static关键字_静态代码块

1).Java中的代码块：是指用一对大括号括起来的一段代码；

class Student{
    public void show(){
        {
            System.out.println("a");
        }
    }
}

2).Java中代码块的分类：

1).构造代码块：编写在"类体中"的，方法外的一对大括号括起来的一段代码

  class Student{
      {
          System.out.println("构造代码块");
      }
  }
  
 1).它在每次创建对象时会被执行一次；
 2).如果有构造方法，它会先于构造方法被执行；
 3).作用：可以用来初始化成员，但没有构造方法使用方便，所以很少使用；

2).静态代码块：编写在"类体中"的，方法外的用static标识的代码块

  class Student{
      static{
          System.out.println("静态代码块");
      }
  }
 1).它在第一次使用这个类(第一次创建对象、第一次访问静态属性)会被执行一次，之后就不会被执行了；
 2).如果与构造代码块，构造方法同时存在，执行顺序：静态代码块-->构造代码块-->构造方法
  class Student{
      static{
          System.out.println("a");
      }
      {
          System.out.println("b");
      }
      public Student(){
          System.out.println("c");
      }

  }
  main(){
      Student stu = new Student();//abc

      Student stu2 = new Student();//bc
  }
 3).作用：用于初始化静态成员变量；

3).局部代码块：定义在某个方法内，使用一对大括号括起来的一段代码；

  class Student{
      public void show(){
          System.out.println("a");
          {
              大对象 d = new 大对象();
              d.XXXX();//使用大对象，之后就不再使用了
          }
          ...
          System.out.println("c");
      }
  }
  main(){
      new Student().show();//abc
  }
  1).作用：限制变量的生命周期；

Java_面向对象_static关键字概述

01.面向对象_static关键字_概念

02.面向对象_static关键字_使用位置_特点

03.面向对象_static关键字_static成员的访问方式

04.面向对象_static关键字_静态代码块