【Java学习专题】static关键字的秘密

什么是static？

static：是java中的关键字，表示”静态的意思“，他可以用来修饰变量、方法、代码块。修饰的变量是静态变量，修饰的方法时静态方法，修饰的代码块是静态代码块。在java中只要是static修饰的都是和类相关的，直接通过类名的方式进行访问。

什么时候将变量定义为静态变量？

静态变量：被static修饰的成员变量就是静态变量，没有被static修饰的成员变量叫实例变量；静态变量是类级别的，可以直接通过类名进行访问，静态变量存储在方法区中，类加载的时候初始化；而实例变量是对象级别的，必须要通过引用才可以访问，实例变量存储在堆内存中，在构造方法执行过程中初始化。

了解了基本概念，那么它到底在什么时候使用呢？当一个成员变量非常的稳定，基本不发生任何变化的时候，也就是说，不会因为对象的不同而有所不同的时候，就可以把这个变量变为静态变量。这样可以避免对堆内存空间的浪费，被访问的时候还不需要实例化，直接用类名的方式进行访问就行。

实例代码：

/**
 * @author Jason
 * @create 2020-04-22 9:36
 */
public class ChineseTest {
  public static void main(String[] args) {
    Chinese c1 = new Chinese("Jason",28,true);
    System.out.println("姓名："+c1.getName());
    System.out.println("年龄："+c1.getAge());
    System.out.println("性别："+(c1.isGender() ? "男" : "女"));
    System.out.println("国籍："+ Chinese.country);

    System.out.println("===========================================");

    Chinese c2 = new Chinese("rose",26,false);
    System.out.println("姓名："+c2.getName());
    System.out.println("年龄："+c2.getAge());
    System.out.println("性别："+(c2.isGender() ? "男" : "女"));
    System.out.println("国籍："+ Chinese.country);
  }
}


/**
 * @author Jason
 * @create 2020-04-22 9:32
 */
public class Chinese {
  private String name;
  private int age;
  private boolean gender;
  static String country="中国";

  public Chinese() {
  }

  public Chinese(String name, int age, boolean gender) {
    this.name = name;
    this.age = age;
    this.gender = gender;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public int getAge() {
    return age;
  }

  public void setAge(int age) {
    this.age = age;
  }

  public boolean isGender() {
    return gender;
  }

  public void setGender(boolean gender) {
    this.gender = gender;
  }

  public static String getCountry() {
    return country;
  }

  public static void setCountry(String country) {
    Chinese.country = country;
  }
}

什么时候把方法定义为静态方法？

当方法体中需要直接访问当前对象的实例变量或实例方法的时候，该方法必须为实例方法。

实例代码：

/**
 * @author Jason
 * @create 2020-04-22 11:20
 */
public class CustomerTest {
  public static void main(String[] args) {
    Customer Jason = new Customer("Jason");
    Jason.shopping();
    Customer Rose = new Customer("Rose");
    Rose.shopping();
  }
}

/**
 * @author Jason
 * @create 2020-04-22 11:16
 */
public class Customer {
  String name;

  public Customer(String name) {
    this.name = name;
  }

  public void shopping(){
    System.out.println(this.name+"正在购物...");
    pay();
  }

  public void pay(){
    System.out.println(this.name+"正在支付...");
  }
}

静态代码块什么时候使用？

静态代码块：用static修饰的代码块，一般在类加载的时候执行，并且只执行一次。

那么我们在什么时候使用呢？很简单，就是在类加载的时候需要执行一段代码，一般情况是在main方法之前执行。当然有多个静态代码块的时候，他们是按照自上而下的顺序执行的。

实例代码：

/**
 * @author Jason
 * @create 2020-04-22 11:02
 * 测试静态代码块的执行顺序
 * 下面代码执行顺序是：1/3/2
 */
public class StaticTest01 {
  static {
    System.out.println(1);
  }
  public static void main(String[] args) {
    System.out.println(2);
  }
  static {
    System.out.println(3);
  }
}

类体中的代码有执行顺序要求吗？

static修饰的静态变量和静态代码块是有先后执行顺序的，自上而下的顺序执行。

空引用访问静态变量和静态方法会出现空指针异常吗？

在实例变量和实例方法中必须先创建对象然后通过引用方式进行访问，如果这个时候用空引用去访问实例相关成员，必然会出现空指针异常。而静态方法、静态变量直接是使用类名去访问，尽管静态相关成员也能使用引用去访问，而且用空引用去访问也不会出现空指针异常，但是不建议样做。