java基础 关键字static

static使用简介

作用域：static（静态）可以声明 内部类 方法 变量 代码块

	// static 修饰变量
    static int b = 20;

	// static 代码块
    static {
        System.out.println("静态代码块执行");
    }

	// static 方法
    static int initA() {
        return 10;
    }
    
    // 静态内部类
	static class StaticInner {}

static结合类的生命周期

想完整了解static功能，需要先了解类的生命周期包括
1.加载（Loading）
2.链接（Linking）：又分验证（Verification）准备（Preparation）和解析（Resolution）三个子阶段
3.初始化（Initialization）
4.使用（Using）
5.卸载（Unloading）

1.加载

类加载简化过程:.java类文件-->java.exec编译器-->.class文件-->类加载器ClassLoader加载
						-->将 .class 字节码文件加载到内存，生成 Class 对象（存储在方法区）

将 .class 字节码文件加载到内存，生成Class 对象（存储在方法区），注意是存储在jvm方法区
触发条件：需要主动使用类时触发（如 new、访问静态成员、反射等调用，虚拟机入口类)

// 首次new对象时触发加载
MyClass obj = new MyClass();

通过调用Class.forName(ClassName)方法，其中ClassName是类的全限定名

String className = "com.example.MyClass";
try {
    Class<?> clazz = Class.forName(className);
    // 现在你可以使用clazz对象来操作MyClass类了
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

访问静态成员

    public static int staticVariable = 10;

    public static void main(String[] args) {
        // 访问静态变量
        System.out.println("Static variable value: " + staticVariable);
    }

虚拟机入口类：main方法

public class Demo{
    public static void main(String[] args) {
        System.out.println("main 方法执行");// 并没有创建类对象实例，但已经进行类加载
    }
}

初始化子类,父类被加载，这个不进行代码示例了，类加载的触发条件说白了，需要使用到该类再进行加载。类加载的原则：延迟加载，能不加载就不加载

2.链接

(1) 验证（Verification）

目标：确保字节码符合 JVM 规范，防止恶意代码或错误格式等

(2) 准备（Preparation）

目标：为类的静态变量分配内存并赋默认值（零值）

static int value = 123;  // 准备阶段 value = 0，等到初始化阶段赋值为 123

(3) 解析（Resolution）

目标：常量化： 将常量池中(final修饰)的符号引用（如类名、方法名）替换为直接引用（内存地址）

String s = "Hello";  // 符号引用 "Hello" 转为实际字符串对象地址

3. 初始化

目标：执行类的初始化代码（静态变量赋值和静态代码块）
关键过程：
①JVM 生成 方法，合并所有静态变量赋值和静态代码块
②若存在父类，先初始化父类（接口不会触发父接口初始化）

public class MyClass {
    static {
        System.out.println("静态代码块执行");
    }
    static int value = 20;
    
    public static void main(String[] args) {
        // 运行会发现 value为20  并且 静态代码块里面的内容执行了
        System.out.println("Static variable value: " + value);
    }
}

注意：
1.这个时候还没有对象实例，对象实例是在栈中，而这里静态变量没有对象可以依靠，存在方法区
2.初始化这里进行的是 给静态变量赋值 和 静态代码块，静态方法并不会自动初始化执行

静态方法的执行规则
1.静态方法不会自动执行：除非被显式调用（如通过类名调用 MyClass.staticMethod()）或在初始化阶段通过静态变量赋值或静态代码块间接调用

2.若静态方法未被任何代码触发：它永远不会执行

public class Test {
    static {
        System.out.println("静态代码块执行");
    }
    // 静态方法不会自动执行
    public static void staticMethod() {
        System.out.println("静态方法被调用");
    }
    
    public static void main(String[] args) {
        System.out.println("程序启动");
    }
}

输出打印

静态代码块执行
程序启动

说明静态方法在初始化时候并不会主动执行，下面显式调用方式

public class StaticTest {
    static int a = initA();         // 静态变量 调用静态方法赋值

    static {
        System.out.println("静态代码块");
        System.out.println(initA()); // 静态代码块 调用静态方法
    }

    static int initA() {
        System.out.println("静态方法 initA 被调用");
        return 10;
    }


    public static void main(String[] args) {
        System.out.println("main 方法执行");
        StaticTest.initA();  // 显式调用静态方法
    }
}

打印

静态方法 initA 被调用
静态代码块
静态方法 initA 被调用
10
main 方法执行
静态方法 initA 被调用

4.使用

目标：通过实例化、方法调用等方式使用类

public class MyClass {
    { 
      System.out.println("非静态代码块"); 
    }
    
    public MyClass() {
     System.out.println("构造函数"); 
    }
	
	public  void method() {
        System.out.println("非静态method方法运行");
    }

    public static void main(String[] args) {
       System.out.println("main运行");// 仅运行入口main方法 不创建对象实例
    }    

    public static void main(String[] args) {
        MyClass obj = new MyClass();  // 输出：非静态代码块 → 构造函数
    }
}

关键行为：
首先实例化：调用构造函数 ，这个时候进行初始化实例变量和非静态代码块

new对象--》设定个类名 通过类名找Class对象 -->初始化实例变量和非静态代码块 -->分配内存

其次方法调用：显示调用执行实例方法或静态方法。这点一样 方法都需要显示调用执行
最后字段访问：读写静态或实例变量，在创建对象实例后，静态或非静态变量都初始化完成都可以访问了，只不过静态变量在类加载就进行初始化，而实例变量是在创建对象实例后才进行初始化

5.卸载

目标：从内存中移除不再使用的类

触发条件（需同时满足）
1.类的所有实例已被回收。
2.类的 Class 对象无引用（如无反射访问）。

加载该类的 ClassLoader 已被回收，即Class对象不在了，如果再次需要使用该类，那么上述的从加载到卸载流程再来一遍

总结

1.类加载只发生一次，实例化可多次进行，实例化对象(Object)需依靠类加载（需要引用Class对象）

2.类加载生成Class对象，如果类中包含内部类，会生成多个Class对象，Class对象即类本身，一个类对应一个Class对象，存在jvm的方法区

3.静态代码块在初始化阶段执行，静态变量在链接 准备阶段赋值默认值，在初始化阶段重新赋静态值

4.静态方法的执行需要显示调用，具体的运行阶段取决于执行者

staic作用总结

静态变量

上面我们了解到 静态变量在链接 准备阶段赋值默认值，在初始化阶段重新赋静态值，由于类加载只进行一次，内存中只有独一份的静态变量值，所以类所有实例共享同一份数据（内存中只有一份拷贝）

静态代码块

类加载时执行一次，用于初始化静态资源，也仅执行一次

静态方法

注意Static的使用注意规则
1、静态只能访问静态。
2、非静态既可以访问非静态的，也可以访问静态的。

①需要显示调用才会运行，这点和实例方法没有区别，可直接通过类名调用
②由于静态只能访问静态，所以在类初始化时，可以通过静态变量或静态代码块调用 静态方法，从而让静态方法也可以在类初始化阶段运行，这点实例方法做不到，因为静态不能访问非静态的
③静态方法不能访问实例成员(非静态)（无 this 上下文）

静态内部类

这里特别需要说明的是 静态内部类，在Java中，将一个类的定义放在另外一个类的定义内部，这就是内部类，添加了静态修饰的内部类就是静态内部类

public class TopLevelClass {  
    // 静态内部类
    static class StaticInner { 
    	..................................
    }

	//调用静态内部类的方式
	TopLevelClass.StaticInner staticInner = new TopLevelClass.StaticInner();
	//或者
	StaticInner staticInner = new StaticInner();
}

考虑几个问题
1.为什么static修饰类只能修饰内部类，不能修饰外层类，如上TopLevelClass
2.为什么通过staic修饰内部类，即静态内部类的好处在哪里
3.静态内部类的加载运行 以及实例化 消亡时机都是什么

问题1.为什么static修饰类只能修饰内部类，不能修饰外层类，如上TopLevelClass
外层类是在包下面的，他的创建不依附于其余的类的实例，直接new就可以，本身是顶级结构。而static 表示“不依赖实例”，通过上面类加载是生命周期就可以看出，类没有创建实例之前在加载之后的初始化static修饰的就可以运行工作，所以外层类不依赖其余的类的实例，static 表示“不依赖实例”，外层类再使用static就属于多此一举了

问题2.为什么通过staic修饰内部类，即静态内部类的好处在哪里
这个要从成员内部类说，内部类就是一个类放在另一个类，那么内部类就属于外层类的成员，内部类有很多好处，比如封装性 隐藏性 实现回调函数 等等

成员内部类的就是非静态的内部类

public class Demo {
	// 非静态内部类：成员内部类
    class NoStaticInner {
    ----------------------------------------
    }
	// 调用方式
	Demo.NoStaticInner = new Demo.NoStaticInner();

	// 实际上就相当于
	Demo demo = new Demo();
	Demo.NoStaticInner noStaticInner = demo.new NoStaticInner(); // 通过外部实例.new创建
    }
}

成员内部类的实例化必须依赖外部类的实例，因为它隐含持有外部类对象的引用
1.成员内部类通过 demo.new 实例化，隐含持有外部类实例的引用（Demo.this）
2.好处是 可直接访问外部类的实例成员，因为非static隐含持有外部类实例的引用（Demo.this）

再来看静态内部类

public class Demo {
	// 静态内部类
    static class StaticInner {
    ----------------------------------------
    }
	// 直接通过类名实例化，无需外部类实例
	Demo.StaticInner staticInner= new Demo.StaticInner();

	// 实际上就相当于，和Demo实例化无关
	StaticInner staticInner= new StaticInner();
	// 因为在Demo类中，所以看上去是和成员内部类一样Demo.StaticInner,Demo.StaticInner表示路径
    }
}

静态内部类的实例化不依赖外部类的实例，因为它没有外部类对象的隐含引用
1.静态内部类通过 new Outer.StaticInner() 直接实例化。不持有外部类实例的引用，因此更节省内存
2.只能访问外部类的静态成员（如 staticOuterField）。static不持有外部类实例的引用（Demo.this）

总结下来就是
1.好处解耦了：成员内部类实例化依靠外层类，静态内部类实例化不依靠外层类
2.坏处是引用受限制: static不持有外部类实例的引用（Demo.this）不能访问外层类的非静态内容

问题3.静态内部类的加载运行 以及实例化 消亡时机都是什么
静态内部类也是类，加载运行实例化也和正常类一样，需要主动触发，但属于内部类，所以受外部类的管理，由外部类的类加载器卸载触发，通常发生在动态模块化环境（如热部署）中