static修饰符

static可以修饰类的成员变量，成员方法，代码块。

• static修饰的成员变量是静态变量，可通过<类名.变量>来访问。
• static修饰的成员方法是静态方法，可通过<类名.方法>来访问。
• static修饰的代码块是静态代码块，当Java虚拟机加载类时会执行该代码块。
  被static修饰的成员变量和成员方法为某个类所有，它不依赖于类的特定实例，它被类的所有实例所共享。

static变量

        没有被static修饰的变量是实例变量。
静态变量和实例变量区别：

• 静态变量在内存中只有一个备份，运行时Java虚拟机只为它分配一次内存，在加载类的过程中完成静态变量的内存分配。
• 每创建一个实例，就会为实例变量分配一次内存，实例变量在内存中有多个备份，互不干扰影响。

在类内部，可以在任何方法里直接访问静态变量；在其他类中，通过<类名.变量>访问。

public class A {
    static int var1;
    void method() {
        int var2 = var1;//类内部直接访问 var1
    }
}
class B{
    void method() {
        int var2 = A.var1;//类名.变量来访问 var1
    }
}

它不依赖于类的特定实例，它被类的所有实例所共享

public class Main {
    static int var = 0;
    public static void main(String[] args) {
      var++;//直接访问
      Main m1 = new Main();
      m1.var++;//引用变量访问
      Main m2 = new Main();
      m2.var++;
      Main.var++;//类名.变量访问
      System.out.println(var);//结果为4
    }
}

static方法

        静态方法和静态变量一样，不用创建类的实例，直接用类名访问。

1. 静态方法可访问的内容

        静态方法由于不需要实例就可调用，所以静态方法里不能使用this和super关键字，也不能直接访问所属类的实例变量和实例方法，但可以直接访问静态变量和静态方法。

2.实例方法可访问的内容

        实例方法中可以直接访问所属类的静态变量，静态方法，实例变量，实例方法。其他类的静态变量和静态方法一般用<类名.变量||方法>来访问。

public class A {
    static int var1;
    int var2;
    static void method1() {
        System.out.println("static method1");
    }
    void method2() {
        System.out.println("method2");
    }
    
    void method() {
        var1++;//访问静态变量
        var2++;//访问实例变量
        method1();//访问静态方法
        method2();//访问实例方法
    }
}

3.静态方法必须被实现

        静态方法不依赖于类的实例，也不依赖于子类，所以静态方法必须自己实现自己的方法，所以静态方法不能被定义为抽象方法。static 和 abstract 永远不能一起使用。

4.为什么程序入口的main()方法是static方法

        通过上面的介绍可以知道，静态方法不依赖于类的实例。所以当main()方法定义为static方法，Java虚拟机只要加载了main()方法所属的类，就能直接执行main()方法，而不需要创建类的实例来调用main()。

public class A {
    public static void main(String[] args) {
        Main m = new Main();//创建实例
        m.main(null);//引用变量访问
      }   
}
class Main {
    public void main(String[] args) {        
      System.out.println("main");
    }    
}

static代码块

        静态代码块不存在于任何方法体中，Java虚拟机加载类时会执行静态代码块，如果类中有多个静态代码块，那么按照类中的先后顺序执行。每个静态代码块只会执行一次。

运行main()方法时，Java虚拟机首先加载类 A，加载过程中依次执行静态代码块。当加载完毕后，再执行main()方法。

public class A {
    static int var = 0;
    static {
        System.out.println(var+1);
    }
    static {
        System.out.println(var+2);
    }
    public static void main(String[] args) {
        System.out.println(var+3);
      }   
}
/*运行结果为
1
2
3*/

静态代码块和静态方法一样，不能直接访问类的实例变量和实例方法，通过实例的引用来访问。

static可进行静态导入

        静态导入可以简化代码。静态导入语法（import static）
没有使用静态导入：

public class A {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
      }   
}

使用静态导入：

import static java.lang.Integer.*;
import static java.lang.System.out;
public class A {
    public static void main(String[] args) {
        out.println(MAX_VALUE);
        out.println(MIN_VALUE);
      }   
}

一般是不需要静态导入的，如果需要经常访问同一个类的静态方法或静态变量的时候，可以简化代码。但导入内容过多，则可能会引起变量或方法名字重复冲突。要避免冲突，就要明确的指定所导入的内容。例如上面可修改为：

import static java.lang.Integer.MAX_VALUE;
import static java.lang.Integer.MIN_VALUE;
import static java.lang.System.out;
public class A {
    public static void main(String[] args) {
        out.println(MAX_VALUE);
        out.println(MIN_VALUE);
      }   
}