静态成员

什么是静态成员？

静态成员（Static Member）是Java中属于类而不是实例的成员。用static关键字修饰的字段或方法被所有对象共享，可以通过类名直接访问，无需创建对象。

实例成员 vs 静态成员:

实例成员（每个对象一份）:
  对象1 ──► [name: 张三] [age: 20]
  对象2 ──► [name: 李四] [age: 22]
  
静态成员（所有对象共享一份）:
  类 ──────────────────► [schoolName: 第一中学] ← 被所有对象共享
                       [studentCount: 2]

静态字段详解

静态字段（也叫类变量）在类加载时就创建，被类的所有实例共享。

public class Student {
    private String name;           // 实例变量 - 每个学生独有
    private static String schoolName = "第一中学";  // 静态变量 - 所有学生共享
    private static int studentCount = 0;  // 静态计数器

    public Student(String name) {
        this.name = name;
        studentCount++;  // 每创建学生，计数器+1
    }

    public void show() {
        System.out.println(name + " - 学校: " + schoolName);
    }

    // 静态方法访问静态变量
    public static int getStudentCount() {
        return studentCount;
    }
}

public class StaticFieldDemo {
    public static void main(String[] args) {
        // 通过类名访问静态变量
        System.out.println("学生总数: " + Student.getStudentCount());

        Student s1 = new Student("张三");
        System.out.println("添加后总数: " + Student.getStudentCount());

        Student s2 = new Student("李四");
        System.out.println("添加后总数: " + Student.getStudentCount());

        // 验证共享性
        System.out.println("\n===== 共享性验证 =====");
        System.out.println("修改前学校: " + Student.schoolName);
        Student.schoolName = "第二中学";  // 通过类名修改
        System.out.println("修改后学校: " + Student.schoolName);
        s1.show();  // 两个对象都显示新的学校名
        s2.show();
    }
}

静态方法详解

静态方法是属于类的方法，可以通过类名直接调用，但不能访问实例成员。

public class WrongExample {
    private int instanceVar = 10;  // 实例变量

    public static void main(String[] args) {
        // 错误！静态方法不能直接访问实例变量
        System.out.println(instanceVar);  // 编译错误！
    }
}

静态代码块

静态代码块在类加载时执行一次，用于初始化静态变量或执行一次性配置。

public class Config {
    private static String url;
    private static String apiKey;
    private static int timeout;

    // 静态代码块 - 类加载时执行一次
    static {
        System.out.println("Config类正在加载...");
        url = "https://api.example.com";
        apiKey = "sk-1234567890abcdef";
        timeout = 5000;
        // 可以执行更复杂的初始化逻辑
        validateConfig();
    }

    // 静态方法
    public static void showConfig() {
        System.out.println("===== 系统配置 =====");
        System.out.println("URL: " + url);
        System.out.println("API Key: " + apiKey.substring(0, 8) + "...");
        System.out.println("超时: " + timeout + "ms");
    }

    private static void validateConfig() {
        if (url == null || url.isEmpty()) {
            throw new IllegalStateException("URL不能为空");
        }
    }
}

public class StaticBlockDemo {
    public static void main(String[] args) {
        // 第一次访问Config类时会触发静态代码块
        Config.showConfig();
    }
}

静态初始化顺序

类加载时的初始化顺序:

1. 静态属性初始化
   ↓ 按声明顺序执行
2. 静态代码块执行
   ↓ 按出现顺序执行
3. 静态方法定义
   ↓ 只是方法定义，不自动执行
4. 静态方法被调用时
   ↓ 才执行方法体
5. 实例创建时
   ↓ 执行构造方法

静态内部类

用static修饰的内部类，不需要外部类实例即可创建。

public class Outer {
    private static int staticVar = 100;
    private int instanceVar = 200;

    // 静态内部类
    public static class StaticInner {
        public void show() {
            // 可以访问外部类的静态成员
            System.out.println("静态变量: " + staticVar);
            // 不能访问外部类的实例成员
            // System.out.println(instanceVar);  // 编译错误！
        }
    }

    // 非静态内部类
    public class Inner {
        public void show() {
            // 可以访问所有外部类成员
            System.out.println("静态: " + staticVar);
            System.out.println("实例: " + instanceVar);
        }
    }
}

public class StaticInnerDemo {
    public static void main(String[] args) {
        // 静态内部类：无需外部类实例
        Outer.StaticInner si = new Outer.StaticInner();
        si.show();

        // 非静态内部类：需要外部类实例
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.show();
    }
}

静态导包（Java 5+）

使用静态导包可以省略类名，直接使用静态成员。

import static java.lang.Math.PI;
import static java.lang.Math.sqrt;
import static java.lang.System.out;

// 之后可以直接使用
public class StaticImportDemo {
    public static void main(String[] args) {
        double radius = 5.0;
        double area = PI * radius * radius;
        out.println("圆的面积: " + area);

        double hypotenuse = sqrt(3*3 + 4*4);
        out.println("直角三角形斜边: " + hypotenuse);
    }
}

静态的典型应用场景

double result = Math.sqrt(16);  // Math是工具类

List list = Arrays.asList("a", "b", "c");

常见错误和注意事项

小结