JAVA中static关键字的用法------静态变量、静态方法、静态类、静态代码块、静态导包

JAVA中static关键字的常见用法

1. 静态变量

变量：

（1）成员变量（全局变量）

1. 独立于方法之外的变量
2. 存放在全局内存中，线程共享，静态变量存放在方法区的静态区，实例变量存放在java堆内存中

• 静态变量（类成员变量）

  通过类名访问；随着类的加载和回收创建和释放；先于对象存在；

• 实例变量

（2）局部变量

1. 在方法中声明的变量，方法内有效
2. 存放在java虚拟机栈中，线程私有

2. 静态方法

1. 在类加载的时候创建
2. 静态方法必须实现，不能使用abstract（抽象）修饰
3. 静态方法内不能直接访问类内的非静态方法和非静态变量，需要声明实例对象访问，无法访问this，super关键字
4. 使用类名访问或类的实例对象访问

3. 静态内部类

1. 创建时不需要外部类的实例对象创建，非静态内部类创建时依赖外部类的实例对象

public class Test {
    class NestedClass { // 非静态内部类
    }
    static class StaticNestedClass { // 静态内部类
    }
    public static void main(String[] args) {
    	Test test = new Test();
        NestedClass NestedClass = test.new NestedClass();
        StaticNestedClass staticNestedClass = new StaticNestedClass();
    }
}

4. 静态代码块

1. 类加载时执行，且只执行一次

public class Test {
    static {
        System.out.println("静态代码块");
    }
    public static void main(String[] args) {
        Test test = new Test();
    }
}

5. 静态导包

1. 静态导入java包或包中某个类静态方法

import static java.lang.System.*; 
import static java.lang.Math.random;
public class Test {
    public static void main(String[] args) {
    	out.print(".....");
    	out.println(random());
    }
}

---

执行顺序

import static java.lang.System.*;
public class Main {
    private static String varible = "静态变量";
    private String varible1 = "非静态变量";
    static {
        out.println("静态代码块中访问静态变量......"+varible);
        Main main = new Main();
        out.println("静态代码块中访问静态变量......"+main.varible1);
        // out.println(varible1); // 非静态变量无法直接访问
    }
    {
        out.println("非静态代码块.....");
    }
    class NestedClass { // 非静态内部类
         NestedClass(){
            out.println("静态内部类初始化......");
        }
    }
    static class StaticNestedClass { // 静态内部类
        StaticNestedClass(){
            out.println("非静态内部类初始化......");
        }
    }
    public static void func(){
        out.println("静态方法中访问静态变量....."+varible);
        // 非静态变量无法直接访问
        Main main = new Main();
        out.println("静态方法中访问非静态变量....."+main.varible1);
    }
    public static void main(String[] args) throws CloneNotSupportedException {
        System.out.println("hello world");
        Main main = new Main();
        NestedClass NestedClass = main.new NestedClass();
        StaticNestedClass staticNestedClass = new StaticNestedClass();
        out.println("main中输出静态变量......"+varible);
        out.println("main中输出非静态变量......"+main.varible1);
        func(); // 使用类名调用静态方法
       // main.func(); // 使用实例对象调用静态方法
    }
}

静态代码块中访问静态变量......静态变量
非静态代码块.....
静态代码块中访问静态变量......非静态变量
hello world
非静态代码块.....
静态内部类初始化......
非静态内部类初始化......
main中输出静态变量......静态变量
main中输出非静态变量......非静态变量
静态方法中访问静态变量.....静态变量
非静态代码块.....
静态方法中访问非静态变量.....非静态变量

1. 首先加载静态变量和静态代码块，静态变量和静态代码块的加载顺序取决于代码的顺序，只执行一次；成员变量和非静态代码块在每次类创建实例对象时执行，执行完成后执行构造函数，可执行多次；
2. 类的初始化，首先加载静态类，静态类加载完成后加载非静态类；