Java基础之static关键字

static 关键字在 Java 中有多种用途，它可以用来修饰变量、方法、代码块以及嵌套类。以下是对 static 关键字在不同场景下的详细解释：

目录

1. 静态变量 (Static Variables)

基本介绍

 使用场景

2. 静态方法 (Static Methods)

基本介绍

使用场景 

3. 静态代码块 (Static Blocks)

4. 静态嵌套类 (Static Nested Classes)

基本介绍

使用场景 

5. 静态导入 (Static Import)

总结

---

1. 静态变量 (Static Variables)

基本介绍

静态变量，也叫类变量，是属于类的，而不是属于类的某个对象的。这意味着，无论创建多少个对象，静态变量在内存中只有一份拷贝。它们被所有对象共享，可以通过类名直接访问。

public class MyClass {
    static int staticVar = 10; // 静态变量

    public static void main(String[] args) {
        System.out.println(MyClass.staticVar); // 通过类名访问静态变量
        MyClass obj1 = new MyClass();
        MyClass obj2 = new MyClass();
        
        obj1.staticVar = 20;
        System.out.println(obj2.staticVar); // 输出 20，表明静态变量被所有对象共享
    }
}

 使用场景

静态变量适用于需要在类的所有实例之间共享的数据。常见的使用场景包括：

• 计数器：跟踪类的实例数量。
• 常量：定义类的常量值，可以使用 static final 组合。
• 共享资源：例如全局配置、缓存等。

public class Counter {
    static int count = 0; // 计数器

    public Counter() {
        count++; // 每创建一个实例，计数器加一
    }

    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        System.out.println("Total instances: " + Counter.count); // 输出 2
    }
}

2. 静态方法 (Static Methods)

基本介绍

静态方法可以通过类名直接调用，而不需要创建对象。静态方法不能访问实例变量和实例方法，只能访问静态变量和静态方法。

public class MyClass {
    static int staticVar = 10;

    static void staticMethod() {
        System.out.println("Static Method");
        System.out.println("Static Variable: " + staticVar); // 访问静态变量
    }

    public static void main(String[] args) {
        MyClass.staticMethod(); // 通过类名调用静态方法
    }
}

使用场景 

静态方法适用于不依赖实例状态（即不依赖实例变量）的行为。常见的使用场景包括：

• 工具方法：如 Math 类中的数学计算方法（Math.sqrt()、Math.random() 等）。
• 工厂方法：用于创建类的实例。
• 辅助方法：与类关联的静态操作。

public class Utility {
    public static int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        int sum = Utility.add(5, 10);
        System.out.println("Sum: " + sum); // 输出 15
    }
}

3. 静态代码块 (Static Blocks)

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

public class MyClass {
    static int staticVar;

    static {
        staticVar = 10;
        System.out.println("Static Block Executed");
    }

    public static void main(String[] args) {
        System.out.println("Static Variable: " + MyClass.staticVar);
    }
}

 关于静态代码域，详细可以参考这篇博客：

Java代码初始化块-CSDN博客

4. 静态嵌套类 (Static Nested Classes)

基本介绍

静态嵌套类是属于外部类的，可以访问外部类的静态变量和方法。要创建静态嵌套类的实例，不需要外部类的实例

public class OuterClass {
    static int outerStaticVar = 10;

    static class NestedStaticClass {
        void display() {
            System.out.println("Outer Static Variable: " + outerStaticVar); // 访问外部类的静态变量
        }
    }

    public static void main(String[] args) {
        OuterClass.NestedStaticClass nestedObj = new OuterClass.NestedStaticClass();
        nestedObj.display();
    }
}

使用场景 

静态嵌套类可以看作是外部类的一部分，但没有外部类实例的引用。这使得它们适用于以下情况： 

• 封装：将一个类的实现细节隐藏在另一个类中。
• 逻辑分组：将相关的类放在一起，尽管它们不需要直接访问外部类的实例变量。

封装复杂的内部实现：

public class OuterClass {
    private int outerVar;

    public OuterClass(int outerVar) {
        this.outerVar = outerVar;
    }

    // 静态嵌套类
    private static class NestedStaticClass {
        private int nestedVar;

        public NestedStaticClass(int nestedVar) {
            this.nestedVar = nestedVar;
        }

        public void print() {
            System.out.println("Nested Variable: " + nestedVar);
        }
    }

    public void createAndPrintNestedClass(int nestedVar) {
        NestedStaticClass nested = new NestedStaticClass(nestedVar);
        nested.print();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass(100);
        outer.createAndPrintNestedClass(200);
    }
}

 逻辑分组：

public class DataStructure {
    private static int size = 10;
    private int[] array = new int[size];

    // 静态嵌套类
    public static class Iterator {
        private int index = 0;

        public void next() {
            if (index < size) {
                System.out.println("Element at " + index);
                index++;
            }
        }
    }

    public static void main(String[] args) {
        DataStructure.Iterator iterator = new DataStructure.Iterator();
        while (iterator.index < DataStructure.size) {
            iterator.next();
        }
    }
}

5. 静态导入 (Static Import)

Java 5 引入了静态导入，可以直接使用静态成员而不需要类名修饰。虽然有助于代码简洁，但滥用可能降低代码可读性。

import static java.lang.Math.*;

public class StaticImportExample {
    public static void main(String[] args) {
        double result = sqrt(25); // 直接使用 Math.sqrt()
        System.out.println("Square root: " + result);
    }
}

总结

• 静态变量：属于类，所有对象共享，通过类名访问。
• 静态方法：属于类，可以通过类名调用，不能访问实例变量和实例方法。
• 静态代码块：用于初始化静态变量，类加载时执行一次。
• 静态嵌套类：属于外部类，可以访问外部类的静态变量和方法，不需要外部类实例即可创建其对象。
• 静态导入： 静态导入后，不用类名修饰直接使用静态成员