Java中关于static关键字的简介

素颜马尾好姑娘i 2023-10-04 12:28 6阅读 0赞

##### 3.static关键字 #####

###### 3.1.概述 ######

*  关于 static 关键字的使用，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。
 *  也就是说，既然属于类，就可以不靠创建对象来调用了。

###### 3.2.定义及其使用 ######

*  类变量：
    
     *  使用 static关键字修饰的成员变量。
     *  当 static 修饰成员变量时，该变量称为类变量。
     *  该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。
 *  静态方法：
    
     *  使用 static关键字修饰的成员方法，习惯称为静态方法。
     *  当 static 修饰成员方法时，该方法称为类方法 。
     *  静态方法在声明中有 static ，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单。
        
        > 静态方法调用的注意事项：
        > 
        >  *  静态方法可以直接访问类变量和静态方法。
        >  *  静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。
        >  *  静态方法中，不能使用this关键字
        >  *  静态方法只能访问静态成员。
 *  Example

public class Student_static {
        
        public static void main(String[] args) {
        
            // 访问类变量
            System.out.println(Student.numberOfStudent);
            // 调用静态方法
            Student.showNum();
        }
    }

###### 3.3.静态代码块 ######

*  定义在成员位置，使用static修饰的代码块\{ \}。
 *  位置：类中方法外。
 *  执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。
 *  作用：给类变量进行初始化赋值，调用方法等。
    
    > static 关键字，可以修饰变量、方法和代码块。在使用的过程中，其主要目的还是想在不创建对象的情况下，去调用方法。

Example：

public class Game {
        
    
        public static int number;
        public static ArrayList<String> list;
    
        static {
        
            // 给类变量赋值
            number = 2;
            list = new ArrayList<String>();
            // 添加元素到集合中
            list.add("张三");
            list.add("李四");
        }
    }

###### 3.4.代码块 ######

###### 3.4.1.普通代码块 ######

*  在Java中，使用大括号”\{\}“括起来的代码被称为代码块，根据其位置和声明方式的不同，可以分为：
    
     *  局部代码块：对于变量的作用域有明确的限制，强制变量成为局部变量，但实际意义不大，严重影响代码可读性，却对内存回收帮助极小
     *  构造代码块：创建对象时，对成员变量进行默认初始化赋值，优先于构造方法运行。
     *  静态代码块：在类加载时，对于静态成员变量进行赋值(且只能给静态成员变量赋值)，与静态成员变量显式初始化语句执行优先级相同，谁在上边谁先执行。
     *  同步代码块（多线程使用）
 *  代码块在实际开发中，使用频率并不高，可替代性也很强，但是由于其迷惑性极强，常年出没于各种面试题中。

###### 3.4.2.构造代码块与静态代码块 ######

public class ExerciseBlock {
        
        static {
        
            System.out.println("静态代码块！");
        }
        {
        
            System.out.println("构造代码块！");
        }
        public static void main(String[] args) {
        
            System.out.println("main方法开始执行！");
            Star s = new Star();
            System.out.println(Star.name);
        }
    }
    
    class Star{
        
        static {
        
            name = "杨幂";
            System.out.println("我喜欢杨幂");
        }
        static String name = "赵四";  //静态成员变量
        {
        
            name = "杨超越";
            System.out.println("我喜欢杨超越");
        }
        public Star() {
        
            name = "123";
            System.out.println("Star：构造器！");
        }
    }
    
    //运行结果：
        静态代码块！
        main方法开始执行！
        我喜欢杨幂
        我喜欢杨超越
        Star：构造器！
        123

*  解释：首先，main方法所在ExerciseBlock类要加载进入方法区，静态代码块随着ExerciseBlock类加载而执行，输出 `静态代码块!` 语句，继而，main方法栈帧进入栈中，main方法开始执行，输出 `main方法开始执行!` 语句，Star类的class文件加载进入方法区，Star的静态变量String name 随之加载进入方法区，并且初始值为 `null` ，因为静态代码块在静态变量赋值语句的上边，所以静态代码块先执行，给name赋值为 `杨幂` ，并输出 `我喜欢杨幂` ，随后，静态变量的赋值语句执行，修改name为 `赵四` ，接着，在堆上创建Star类的s对象，构造代码块开始执行，将name赋值为 `杨超越` ，输出 `我喜欢杨超越` ，最后，构造方法开始执行，将name最后修改为 `123` ，并输出 `Star：构造器！`，因为主方法的输出语句在最后，所以最后输出 `123` ，至此执行完毕。
    
    > 注：
    > 
    > 在程序运行中，静态代码块与静态变量的初始化赋值语句，虽然在真正的程序编写中，很少会给静态变量直接赋初始值，但在面试中会偶尔考察，如上述代码中，静态代码块和静态变量显式初始化语句的优先级是一样的，都是随着类加载进方法区而执行，所以按代码的书写顺序执行，谁在上边谁先执行，而构造代码块和构造方法，都是创建了对象以后才开始执行，且构造方法永远最后执行。
    > 
    > 个人理解，构造方法之所以永远最后执行，是为了程序员进行初始化赋值的时候，保证所赋值的内容永远是想要的内容。
    > 
    > 另：静态的内容，只会随着类加载而执行，因此，类只需加载一次，所以静态的内容也只会执行一次。
 *  额外补充：
    
     *  对于默认初始化赋值，创建对象的时候第一件事情就是默认初始化，这时候成员变量只会赋默认初值，而调用构造方法的时候，不管是隐式的super还是显式的this，都会追溯到父类，在父类调用自己的构造方法之前，成员变量初始化（比如类中定义了int age = 10）这时候就会开始，父类调用完毕后，子类调用自己的构造方法，同理，子类调用之前，也会给自己的成员变量赋值。

class Father {
        
          int i = 10;
          public Father() {
        
              System.out.println(getI());
          }
          public int getI() {
        
              return i;
          }
        }
        
      class Son extends Father {
        
      int i = 100;
      public Son(int i) {
        
          this.i = i;
      }
      public int getI() {
        
          return i;
      }
      
      }
    //对于以上代码，在主方法中，执行Father father = new Son(1000)，输出结果是0；
    //父类方法被子类覆盖，即使在父类中调用，调用到的也是子类方法，而此时父类对象还在初始化过程中，子类对象更是还未开始初始化，其成员变量的值还是默认值。
      
      public class MyStack {
        
    
      int INIT_CAPACITY = 10;// 默认初始容量
    
      
      public MyStack(){
        
    
      // 如果使用者不传数组的初始长度, 默认是10
    
      
      //        this.arr = new Object[INIT_CAPACITY];
    //        this(INIT_CAPACITY);  //报错Cannot reference 'MyStack.INIT_CAPACITY' before supertype constructor has been called
      }
      public MyStack(int capacity){
        
          // 参数检查
          if (capacity <= 0 || capacity > MAX_CAPACITY){
        
              throw new IllegalArgumentException("capacity is Illegal");
          }
          arr = new Object[capacity];
      }
      }
    //对于以上代码，虽然此时MyStack的成员变量，已经有了默认初始值，但是，父类的构造方法，即Object的构造方法，还没有被调用，此时卡在了this中，
    //子类变量依赖于父类存在，JVM不允许这样做，所以直接报错，不能在super()被调用之前使用自己的成员变量。