Java中的static成员+代码块

Java中的 static 成员与代码块：概念与应用

目录

1. 什么是 static 成员
   • static 变量
   • static 方法
   • static 内部类
2. static 代码块
   • static 代码块的作用
   • 执行顺序
   • 使用场景
3. static 的优势与应用
   • 提高内存使用效率
   • 用于常量定义
   • 单例模式
4. static 成员与代码块的实际示例
   • static 变量与方法示例
   • static 代码块示例
   • 组合应用实例
5. 总结与进一步学习

---

1. 什么是 static 成员

static 变量

static 变量是属于类的，而不是类的实例。换句话说，所有类的实例共享同一个 static 变量。static 变量在类加载时初始化，并且在整个程序运行期间存在。

示例代码：

public class MyClass {
    static int count = 0;  // 静态变量，所有实例共享

    MyClass() {
        count++;  // 每次创建对象时，count都会增加
    }

    public static void main(String[] args) {
        MyClass obj1 = new MyClass();
        MyClass obj2 = new MyClass();
        System.out.println("Count: " + MyClass.count);  // 输出：Count: 2
    }
}

static 方法

static 方法属于类，而不是类的实例。静态方法可以直接通过类名调用，而不需要先创建类的实例。static方法不能访问实例变量和实例方法，只能访问其他静态成员。

示例代码：

public class MyClass {
    static int count = 0;

    static void incrementCount() {
        count++;  // 静态方法可以修改静态变量
    }

    public static void main(String[] args) {
        MyClass.incrementCount();  // 通过类名调用静态方法
        System.out.println("Count: " + MyClass.count);  // 输出：Count: 1
    }
}

static 内部类

static 内部类是作为外部类的静态成员而存在的。静态内部类与外部类的实例无关，可以直接通过外部类名访问，并且它只能访问外部类的静态成员。

示例代码：

public class OuterClass {
    static int staticVar = 10;

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

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

---

2. static 代码块

static 代码块的作用

static 代码块是与类本身相关联的，不与类的实例相关。它用于在类加载时执行一次初始化操作，常用于静态变量的初始化或执行一些只需进行一次的操作。static 代码块在类的第一次加载时执行，并且只执行一次。

执行顺序

• static 代码块的执行顺序：类加载时，static 代码块会在类的构造函数和实例化之前执行。
• 如果一个类有多个 static 代码块，它们的执行顺序是按它们在代码中的顺序依次执行的。

使用场景

• 初始化静态变量：static 代码块常用于静态变量的初始化，尤其是在静态变量需要复杂初始化时。
• 类加载时的操作：在类加载时需要执行的一次性操作，如加载配置文件、数据库连接等。

示例代码：

public class StaticBlockExample {
    static int value;

    // 静态代码块，初始化静态变量
    static {
        value = 10;
        System.out.println("Static block executed");
    }

    public static void main(String[] args) {
        System.out.println("Value: " + value);  // 输出：Value: 10
    }
}

执行顺序示例：

public class StaticBlockOrder {
    static {
        System.out.println("First static block");
    }

    static {
        System.out.println("Second static block");
    }

    public static void main(String[] args) {
        System.out.println("Main method");
    }
}

输出：

First static block
Second static block
Main method

---

3. static 的优势与应用

提高内存使用效率

由于 static 成员是类级别的，它们被所有实例共享，这有助于减少内存的使用，特别是在多个对象需要共享相同数据时。比如，计数器、常量池等都可以通过静态成员来管理。

用于常量定义

static 常常与 final 一起使用，用于定义常量。final static 变量可以保证在整个程序中不被修改。

示例代码：

public class Constants {
    public static final double PI = 3.14159;  // 静态常量
}

单例模式

在实现单例模式时，可以使用 static 变量来确保类只有一个实例，并提供一个全局访问点。

示例代码：

public class Singleton {
    private static Singleton instance;

    private Singleton() { }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();  // 延迟实例化
        }
        return instance;
    }

    public void show() {
        System.out.println("Singleton instance");
    }

    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        singleton.show();
    }
}

---

4. static 成员与代码块的实际示例

static 变量与方法示例

public class BankAccount {
    static int totalAccounts = 0;  // 静态变量，记录账户数
    private int accountNumber;

    public BankAccount() {
        accountNumber = ++totalAccounts;
    }

    public static void showTotalAccounts() {
        System.out.println("Total accounts: " + totalAccounts);
    }

    public static void main(String[] args) {
        BankAccount account1 = new BankAccount();
        BankAccount account2 = new BankAccount();
        BankAccount.showTotalAccounts();  // 输出：Total accounts: 2
    }
}

static 代码块示例

public class DatabaseConnection {
    static {
        System.out.println("Initializing database connection...");
        // 模拟数据库连接
    }

    public static void main(String[] args) {
        System.out.println("Main method executed.");
    }
}

输出：

Initializing database connection...
Main method executed.

组合应用实例

public class StaticExample {
    static int staticCount = 0;

    static {
        staticCount = 100;  // 静态代码块初始化静态变量
        System.out.println("Static block executed");
    }

    public static void incrementCount() {
        staticCount++;
        System.out.println("Count: " + staticCount);
    }

    public static void main(String[] args) {
        StaticExample.incrementCount();  // 输出：Count: 101
    }
}

---

5. 总结与进一步学习

• static 成员：它们属于类而非实例。static 变量和方法可以被所有实例共享，适用于那些不依赖于对象状态的场景。
• static 代码块：用于类加载时执行的初始化任务，能够保证类加载时执行一次性操作。
• static 提供了内存共享、常量定义和单例模式等强大的应用场景，使得 Java 中的资源管理和类的行为更加灵活高效。

进一步学习：

• 《Effective Java》：深入理解 static 关键字的使用技巧。
• 《Java编程思想》：学习如何在设计模式中利用 static 变量和方法。