static关键字

static修饰的成员属于类本身，不属于对象实例。

static概念

什么是static

static表示"静态"，修饰的成员属于类级别，不依赖对象。

public class Student {
    // 静态成员变量：属于类
    static int count = 0;
    
    // 静态方法：属于类
    static void showCount() {
        System.out.println("学生数量: " + count);
    }
}

// 通过类名访问静态成员
Student.showCount();  // 不需要创建对象

静态变量

静态成员变量

static修饰的变量属于类，所有对象共享。

public class Student {
    String name;        // 实例变量（每个对象独立）
    static int count;   // 静态变量（所有对象共享）
    
    public Student(String name) {
        this.name = name;
        count++;  // 每创建一个对象，count加1
    }
}

Student s1 = new Student("张三");
Student s2 = new Student("李四");

System.out.println(Student.count);  // 2（共享）

静态变量特点

• 属于类，不属于对象
• 所有对象共享一份
• 通过类名访问：类名.静态变量
• 类加载时初始化

// 访问静态变量
Student.count = 0;     // 类名.静态变量
s1.count = 10;         // 也可通过对象访问（不推荐）
System.out.println(s2.count);  // 10（同一份）

实例变量与静态变量对比

静态方法

静态成员方法

static修饰的方法属于类，可直接通过类名调用。

public class MathUtils {
    // 静态方法
    public static int add(int a, int b) {
        return a + b;
    }
    
    public static int max(int a, int b) {
        return a > b ? a : b;
    }
}

// 直接通过类名调用
int result = MathUtils.add(5, 3);   // 8
int maxValue = MathUtils.max(10, 20);  // 20

静态方法特点

• 属于类，不属于对象
• 通过类名调用：类名.静态方法()
• 不能访问非静态成员（实例变量/方法）
• 不能使用this和super

public class Test {
    int instanceVar;       // 实例变量
    static int staticVar;  // 静态变量
    
    public void instanceMethod() { }
    
    public static void staticMethod() {
        // 不能访问实例成员
        // instanceVar = 10;      // 错误
        // instanceMethod();      // 错误
        
        // 可以访问静态成员
        staticVar = 10;          // 正确
        System.out.println(staticVar);
        
        // 不能使用this
        // this.instanceVar;      // 错误
    }
}

静态方法使用场景

• 工具类方法（如Math类）
• 不需要访问实例成员的方法
• 类级别的操作

public class StringUtils {
    // 工具类静态方法
    public static boolean isEmpty(String str) {
        return str == null || str.isEmpty();
    }
    
    public static String trim(String str) {
        return str == null ? null : str.trim();
    }
}

// 使用
boolean empty = StringUtils.isEmpty(null);  // true

静态代码块

静态代码块语法

static修饰的代码块，类加载时执行一次。

public class Config {
    static String configValue;
    
    // 静态代码块：类加载时执行
    static {
        configValue = "初始化配置";
        System.out.println("静态代码块执行");
    }
}

// 类第一次使用时执行
Config.configValue;  // 输出：静态代码块执行

静态代码块用途

• 类级别的初始化
• 加载配置文件
• 初始化静态变量

public class Database {
    static Connection connection;
    
    static {
        try {
            connection = DriverManager.getConnection(url);
            System.out.println("数据库连接初始化");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

执行顺序

public class Test {
    static int a = 1;          // 1. 静态变量初始化
    
    static {                   // 2. 静态代码块
        a = 2;
        System.out.println("静态代码块");
    }
    
    int b = 3;                 // 3. 实例变量初始化
    
    {                          // 4. 实例代码块
        b = 4;
        System.out.println("实例代码块");
    }
    
    public Test() {            // 5. 构造方法
        System.out.println("构造方法");
    }
}

Test t = new Test();
// 输出：静态代码块 → 实例代码块 → 构造方法

静态内部类

静态内部类

static修饰的内部类，不依赖外部类实例。

public class Outer {
    private int outerVar;
    private static int staticVar = 10;
    
    // 静态内部类
    static class Inner {
        public void method() {
            // 只能访问外部类静态成员
            System.out.println(staticVar);
            // System.out.println(outerVar);  // 错误：不能访问实例成员
        }
    }
}

// 创建静态内部类对象
Outer.Inner inner = new Outer.Inner();  // 不需要外部类实例

静态内部类特点

• 不依赖外部类实例
• 只能访问外部类静态成员
• 创建对象不需要外部类实例

静态导入

静态导入语法

Java 5+支持静态导入，直接使用静态成员无需类名。

// 静态导入
import static java.lang.Math.*;

public class Test {
    public void method() {
        // 直接使用，无需Math前缀
        double value = PI;       // Math.PI
        double result = sqrt(9); // Math.sqrt(9)
        int maxVal = max(1, 2);  // Math.max(1, 2)
    }
}

static使用场景

工具类设计

public class ArrayUtils {
    // 工具类全是静态方法
    public static int[] sort(int[] arr) { ... }
    public static int max(int[] arr) { ... }
    public static int binarySearch(int[] arr, int key) { ... }
    
    // 私有构造，防止创建对象
    private ArrayUtils() { }
}

// 使用
int[] arr = {3, 1, 2};
ArrayUtils.sort(arr);
int max = ArrayUtils.max(arr);

常量定义

public class Constants {
    // 静态常量
    public static final String APP_NAME = "MyApp";
    public static final int MAX_SIZE = 100;
    public static final double PI = 3.14159;
}

// 使用
String name = Constants.APP_NAME;
int size = Constants.MAX_SIZE;

计数器/单例

public class Counter {
    private static int count = 0;
    
    public static int getCount() {
        return count;
    }
    
    public static void increment() {
        count++;
    }
}

Counter.increment();
Counter.increment();
System.out.println(Counter.getCount());  // 2

要点总结

• static修饰的成员属于类，不属于对象
• 静态变量：所有对象共享一份
• 静态方法：通过类名直接调用
• 静态方法不能访问实例成员（非静态）
• 静态方法不能使用this和super
• 静态代码块：类加载时执行一次
• 静态代码块用于类级别初始化
• 静态内部类不依赖外部类实例
• 静态导入可直接使用静态成员
• 工具类设计：静态方法+私有构造