static都有哪些用法?5大用法详解

static关键字在Java中有5种重要的用法：

• 静态变量：用于定义类变量，所有实例共享。
• 静态方法：属于类本身，可以通过类名调用，不能访问非静态成员。
• 静态代码块：用于静态变量的初始化，在类加载时执行一次。
• 静态内部类：独立于外部类实例创建的内部类，不能访问外部类的非静态成员。
• 静态导入：允许在使用静态成员时省略类名，简化代码。

 

1.静态变量

用于定义类变量，所有实例共享，也叫类属性，在类的加载阶段进行初始化。

被static修饰的属性，只要类进行加载以后，便可以使用类名.属性名进行调用。

public class MyClass {
    // 静态变量
    static int staticVariable = 10;
    
    public static void main(String[] args) {
        // 通过类名访问静态变量
        System.out.println(MyClass.staticVariable);
        
        // 可以通过对象访问，但不推荐
        MyClass obj = new MyClass();
        System.out.println(obj.staticVariable);
    }
}

 

2.静态方法

属于类本身，修饰后的方法，可以直接使类名.方法名调用。

public class MyClass {
    // 静态方法
    static void staticMethod() {
        System.out.println("This is a static method.");
    }
    
    public static void main(String[] args) {
        // 通过类名调用静态方法
        MyClass.staticMethod();
        
        // 可以通过对象调用，但不推荐
        MyClass obj = new MyClass();
        obj.staticMethod();
    }
}

静态方法是不能够直接调用同类下的非静态方法，而同类下的非静态方法则可以调用同类下的静态方法。

 

3.静态代码块

用于静态变量的初始化，在类加载时执行一次。

public class InitializationOrder {
    // 静态变量
    static int var1 = initializeVar1();
    static int var2 = 20;
    
    // 静态代码块1
    static {
        System.out.println("Static Block 1");
        System.out.println("var1 = " + var1);
        System.out.println("var2 = " + var2);
        var1 = 50;
    }
    
    // 静态代码块2
    static {
        System.out.println("Static Block 2");
        System.out.println("var1 = " + var1);
        System.out.println("var2 = " + var2);
        var2 = 100;
    }
    
    static int initializeVar1() {
        System.out.println("Initializing var1");
        return 10;
    }
    
    public static void main(String[] args) {
        System.out.println("Main method");
        System.out.println("var1 = " + var1);
        System.out.println("var2 = " + var2);
    }
}

1. 静态变量var1初始化：
   1. 输出：”Initializing var1″
   2. var1被赋值为10。
2. 静态代码块1执行：
   1. 输出：”Static Block 1″
   2. 输出：”var1 = 10″（因为var1已经被初始化）
   3. 输出：”var2 = 20″（var2此时已经被赋值为20）
   4. var1被重新赋值为50。
3. 静态代码块2执行：
   1. 输出：”Static Block 2″
   2. 输出：”var1 = 50″（因为var1在静态代码块1中被重新赋值）
   3. 输出：”var2 = 20″（此时var2还没有被重新赋值）
   4. var2被重新赋值为100。
4. main方法执行：
   1. 输出：”Main method”
   2. 输出：”var1 = 50″（保持静态代码块2中的值）
   3. 输出：”var2 = 100″（保持静态代码块2中的值）

所以，运行结果为：

Initializing var1
Static Block 1
var1 = 10
var2 = 20
Static Block 2
var1 = 50
var2 = 20
Main method
var1 = 50
var2 = 100

 

4.静态内部类

独立于外部类实例创建的内部类，不能访问外部类的非静态成员。

public class OuterClass {
    static class StaticInnerClass {
        void display() {
            System.out.println("Inside static inner class.");
        }
    }
    
    public static void main(String[] args) {
        // 创建静态内部类的实例
        OuterClass.StaticInnerClass inner = new OuterClass.StaticInnerClass();
        inner.display();
    }
}

 

5.静态导入

允许在使用静态成员时省略类名，简化代码。

import static java.lang.Math.*;

public class MyClass {
    public static void main(String[] args) {
        // 可以直接使用Math类的静态成员
        System.out.println(sqrt(16));  // 相当于Math.sqrt(16)
        System.out.println(PI);        // 相当于Math.PI
    }
}

 

mikechen睿哥

10年+大厂架构经验，资深技术专家，就职于阿里巴巴、淘宝、百度等一线互联网大厂。