Java静态（static）关键字详解
摘要
static是Java中的重要关键字，用于修饰类的成员变量、成员方法和代码块。static成员属于类级别，不依赖对象实例，存储在方法区中，被所有对象共享，可直接通过类名访问。
目录
概述
static关键字定义
static关键字可以用来修饰类的成员变量、成员方法或者代码块（注意：只能修饰成员）。
核心特性
当需要定义一个类成员，且它的使用不依赖于该类的任何对象时，就需要使用static关键字。
重要特征：
- 在创建该类的任何对象之前就可以访问static成员
main()方法声明为static，所以不用创建类的实例就可以被JVM调用
内存分配
static成员的存储位置：
- ❌ 不在堆内存
- ❌ 不在栈内存
- ✅ 在方法区（也叫共享区、数据区）
共享特性
- 声明静态成员时，不会生成副本
- 类的所有实例都共享同一个静态变量
- 可以通过类名调用静态成员
- 也可以通过对象引用调用静态成员（不推荐）
static用法
1. 静态变量
语法格式
static 数据类型 变量名 = 初始值;
示例
public class StaticVariableDemo {
// 静态变量
static String companyName = "ABC公司";
static int employeeCount = 0;
// 实例变量
private String name;
private int id;
public StaticVariableDemo(String name, int id) {
this.name = name;
this.id = id;
employeeCount++; // 每创建一个员工，总数+1
}
public void showInfo() {
System.out.println("员工: " + name + ", ID: " + id);
System.out.println("公司: " + companyName + ", 总员工数: " + employeeCount);
}
public static void main(String[] args) {
// 直接通过类名访问静态变量
System.out.println("公司名称: " + StaticVariableDemo.companyName);
System.out.println("初始员工数: " + StaticVariableDemo.employeeCount);
// 创建对象，观察静态变量变化
StaticVariableDemo emp1 = new StaticVariableDemo("张三", 1001);
StaticVariableDemo emp2 = new StaticVariableDemo("李四", 1002);
emp1.showInfo();
emp2.showInfo();
// 输出:
// 公司名称: ABC公司
// 初始员工数: 0
// 员工: 张三, ID: 1001
// 公司: ABC公司, 总员工数: 2
// 员工: 李四, ID: 1002
// 公司: ABC公司, 总员工数: 2
}
}
2. 静态方法
语法格式
[访问修饰符] static 返回类型 方法名(参数列表) {
// 方法体
}
示例
public class MathUtils {
// 静态方法：计算两个数的最大值
public static int max(int a, int b) {
return a > b ? a : b;
}
// 静态方法：计算圆的面积
public static double getCircleArea(double radius) {
return Math.PI * radius * radius;
}
// 静态方法：格式化数字
public static String formatNumber(double number, int decimals) {
return String.format("%." + decimals + "f", number);
}
public static void main(String[] args) {
// 直接通过类名调用静态方法
int maxValue = MathUtils.max(10, 20);
double area = MathUtils.getCircleArea(5.0);
String formatted = MathUtils.formatNumber(3.14159, 2);
System.out.println("最大值: " + maxValue); // 20
System.out.println("圆面积: " + area); // 78.53981633974483
System.out.println("格式化数字: " + formatted); // 3.14
}
}
3. 静态代码块
特点
- 随着类的加载而执行
- 只执行一次
- 用于类的初始化操作
语法格式
static {
// 静态代码块内容
}
示例
public class StaticBlockDemo {
static String config;
static int maxConnections;
// 静态代码块：类加载时执行，用于初始化
static {
System.out.println("静态代码块执行 - 类初始化开始");
config = "production";
maxConnections = 100;
System.out.println("配置加载完成: " + config);
}
// 构造代码块：每次创建对象时执行
{
System.out.println("实例代码块执行 - 对象创建");
}
// 构造函数
public StaticBlockDemo() {
System.out.println("构造函数执行");
}
public static void main(String[] args) {
System.out.println("main方法开始");
// 第一次创建对象
StaticBlockDemo obj1 = new StaticBlockDemo();
System.out.println("---");
// 第二次创建对象
StaticBlockDemo obj2 = new StaticBlockDemo();
// 输出顺序:
// 静态代码块执行 - 类初始化开始
// 配置加载完成: production
// main方法开始
// 实例代码块执行 - 对象创建
// 构造函数执行
// ---
// 实例代码块执行 - 对象创建
// 构造函数执行
}
}
4. 静态成员的调用
public class StaticCallDemo {
static String staticVar = "静态变量";
String instanceVar = "实例变量";
public static void staticMethod() {
System.out.println("静态方法");
}
public void instanceMethod() {
System.out.println("实例方法");
}
public static void main(String[] args) {
// 方式1：通过类名调用（推荐）
System.out.println(StaticCallDemo.staticVar);
StaticCallDemo.staticMethod();
// 方式2：通过对象引用调用（不推荐，但合法）
StaticCallDemo obj = new StaticCallDemo();
System.out.println(obj.staticVar); // 编译器会警告
obj.staticMethod(); // 编译器会警告
// 非静态成员必须通过对象调用
System.out.println(obj.instanceVar);
obj.instanceMethod();
}
}
static特点
1. 加载时机
静态成员随着类的加载而加载
- 只要类被加载，类的静态成员就会存在
- 静态成员可以被调用
- 随着类的消失而消失
- 生命周期最长
2. 存在顺序
静态成员优先于对象存在
- 静态成员先存在
- 对象后存在
3. 共享性
被所有对象所共享
public class SharedStaticDemo {
static int count = 0;
public SharedStaticDemo() {
count++;
}
public static void main(String[] args) {
System.out.println("初始count: " + count); // 0
SharedStaticDemo obj1 = new SharedStaticDemo();
System.out.println("创建obj1后count: " + count); // 1
SharedStaticDemo obj2 = new SharedStaticDemo();
System.out.println("创建obj2后count: " + count); // 2
SharedStaticDemo obj3 = new SharedStaticDemo();
System.out.println("创建obj3后count: " + count); // 3
// 所有对象都共享同一个count变量
System.out.println("obj1.count: " + obj1.count); // 3
System.out.println("obj2.count: " + obj2.count); // 3
System.out.println("obj3.count: " + obj3.count); // 3
}
}
4. 访问方式
可以直接被类名调用
5. 内存位置
静态成员存储在方法区
类变量与实例变量区别
对比表
| 特性 | 类变量（静态变量） | 实例变量（非静态变量） |
|---|---|---|
| 修饰符 | static | 无static |
| 存放位置 | 方法区 | 堆内存 |
| 生命周期 | 类加载到类卸载 | 对象创建到对象销毁 |
| 共享性 | 所有实例共享 | 每个实例独有 |
| 访问方式 | 类名.变量名（推荐） 对象.变量名 | 对象.变量名 |
| 初始化时机 | 类加载时 | 对象创建时 |
详细对比示例
public class VariableComparison {
// 类变量（静态变量）
static String school = "清华大学";
static int totalStudents = 0;
// 实例变量
private String name;
private int studentId;
public VariableComparison(String name, int studentId) {
this.name = name;
this.studentId = studentId;
totalStudents++; // 每创建一个学生，总数加1
}
public void displayInfo() {
System.out.println("学生姓名: " + name); // 实例变量
System.out.println("学号: " + studentId); // 实例变量
System.out.println("学校: " + school); // 类变量
System.out.println("总学生数: " + totalStudents); // 类变量
System.out.println("---");
}
public static void main(String[] args) {
// 在创建任何对象前，静态变量就存在
System.out.println("学校名称: " + VariableComparison.school);
System.out.println("当前学生数: " + VariableComparison.totalStudents);
// 创建学生对象
VariableComparison student1 = new VariableComparison("张三", 2021001);
VariableComparison student2 = new VariableComparison("李四", 2021002);
student1.displayInfo();
student2.displayInfo();
// 修改静态变量，所有实例都会受影响
VariableComparison.school = "北京大学";
System.out.println("\n学校更名后:");
student1.displayInfo();
student2.displayInfo();
}
}
主函数详解
main方法的定义
public static void main(String[] args)
各部分含义
| 关键字 | 含义 | 说明 |
|---|---|---|
public | 访问权限最大 | JVM需要从外部访问 |
static | 静态方法 | 随着类的加载已经存在，无需创建对象 |
void | 无返回值 | main方法不需要返回值 |
main | 方法名 | 不是关键字，但是JVM可识别的特殊单词 |
String[] args | 参数 | 字符串数组，接收命令行参数 |
为什么main方法是static？
public class WhyMainStatic {
public static void main(String[] args) {
System.out.println("JVM调用main方法时:");
System.out.println("1. 不需要创建WhyMainStatic对象");
System.out.println("2. 直接通过类名调用main方法");
System.out.println("3. 如果main不是static，JVM需要先创建对象");
System.out.println("4. 但创建对象又需要调用构造函数");
System.out.println("5. 这就形成了循环依赖");
}
// 如果main不是static，会怎样？
// public void main(String[] args) { // ❌ JVM找不到入口点
// System.out.println("这个方法JVM无法调用");
// }
}
命令行参数使用
public class CommandLineArgs {
public static void main(String[] args) {
System.out.println("接收到 " + args.length + " 个参数:");
for (int i = 0; i < args.length; i++) {
System.out.println("参数[" + i + "]: " + args[i]);
}
// 使用增强for循环
System.out.println("\n所有参数:");
for (String arg : args) {
System.out.println("- " + arg);
}
}
}
// 运行方式：java CommandLineArgs hello world 123
// 输出:
// 接收到 3 个参数:
// 参数[0]: hello
// 参数[1]: world
// 参数[2]: 123
使用注意事项
1. 静态方法只能访问静态成员 ⚠️
public class StaticAccessDemo {
static String staticVar = "静态变量";
String instanceVar = "实例变量";
// ✅ 静态方法访问静态成员（正确）
public static void staticMethod() {
System.out.println(staticVar); // ✅ 可以访问静态变量
staticHelper(); // ✅ 可以调用静态方法
// System.out.println(instanceVar); // ❌ 编译错误！
// instanceMethod(); // ❌ 编译错误！
}
public static void staticHelper() {
System.out.println("静态辅助方法");
}
// ✅ 非静态方法可以访问所有成员（正确）
public void instanceMethod() {
System.out.println(staticVar); // ✅ 可以访问静态变量
System.out.println(instanceVar); // ✅ 可以访问实例变量
staticMethod(); // ✅ 可以调用静态方法
staticHelper(); // ✅ 可以调用其他实例方法
}
}
2. 静态方法中不能使用this、super关键字 ⚠️
public class StaticThisSuper {
static String staticVar = "静态变量";
String instanceVar = "实例变量";
public static void staticMethod() {
// System.out.println(this.staticVar); // ❌ 编译错误！
// System.out.println(super.toString()); // ❌ 编译错误！
// 原因：静态优先于对象存在，this和super代表对象引用
System.out.println(staticVar); // ✅ 直接访问静态成员
}
public void instanceMethod() {
System.out.println(this.instanceVar); // ✅ 可以使用this
System.out.println(super.toString()); // ✅ 可以使用super
}
}
3. 静态方法不能被重写 ⚠️
class Parent {
public static void staticMethod() {
System.out.println("父类静态方法");
}
public void instanceMethod() {
System.out.println("父类实例方法");
}
}
class Child extends Parent {
// 这不是重写，而是隐藏（hiding）
public static void staticMethod() {
System.out.println("子类静态方法");
}
@Override
public void instanceMethod() {
System.out.println("子类实例方法"); // 这是真正的重写
}
}
public class StaticOverrideDemo {
public static void main(String[] args) {
Parent parent = new Child();
parent.staticMethod(); // 输出: 父类静态方法（看引用类型）
parent.instanceMethod(); // 输出: 子类实例方法（看实际对象类型）
Child.staticMethodd(); // 输出: 子类静态方法
Parent.staticMethod(); // 输出: 父类静态方法
}
}
静态的利与弊
优点
1. 节省内存空间
public class MemorySavingDemo {
static String companyName = "ABC公司"; // 所有员工共享，只存储一份
String employeeName; // 每个员工都有自己的副本
// 如果不用static，每个对象都会有companyName的副本
// 1000个员工 = 1000个companyName副本 = 浪费内存
// 使用static，1000个员工共享1个companyName = 节省内存
}
2. 便于工具类设计
// 数学工具类：不需要创建对象，直接使用
public class MathUtil {
public static final double PI = 3.14159;
public static int add(int a, int b) { return a + b; }
public static int multiply(int a, int b) { return a * b; }
// 私有构造函数，防止实例化
private MathUtil() { }
}
// 使用：MathUtil.add(10, 20);
3. 全局配置管理
public class AppConfig {
public static final String APP_NAME = "我的应用";
public static final String VERSION = "1.0.0";
public static boolean debugMode = false;
public static void setDebugMode(boolean debug) {
debugMode = debug;
}
}
缺点
1. 生命周期过长
public class LongLifeCycleDemo {
static List<String> cache = new ArrayList<>(); // 类加载就创建，程序结束才销毁
public static void addToCache(String data) {
cache.add(data); // 可能导致内存泄漏
}
// 解决方案：提供清理方法
public static void clearCache() {
cache.clear();
}
}
2. 访问局限性
public class AccessLimitationDemo {
static String staticVar = "静态变量";
String instanceVar = "实例变量";
// 静态方法的局限性
public static void staticMethod() {
System.out.println(staticVar); // ✅ 只能访问静态成员
// System.out.println(instanceVar); // ❌ 不能访问实例成员
// instanceMethod(); // ❌ 不能调用实例方法
}
public void instanceMethod() {
System.out.println(staticVar); // ✅ 可以访问静态成员
System.out.println(instanceVar); // ✅ 可以访问实例成员
}
}
3. 测试难度增加
// 静态方法难以进行单元测试和模拟（Mock）
public class TestingDifficulty {
public static String getSystemTime() {
return new Date().toString(); // 直接依赖系统时间，难以测试
}
// 更好的设计：依赖注入
private TimeProvider timeProvider;
public String getCurrentTime() {
return timeProvider.getCurrentTime(); // 可以注入Mock对象进行测试
}
}
使用场景
1. 何时使用静态变量？
使用原则：当对象中出现共享数据时，该数据被static修饰。
✅ 适合使用static的场景
public class StaticVariableScenarios {
// 1. 常量定义
public static final double PI = 3.14159;
public static final String APP_VERSION = "1.0.0";
// 2. 计数器
static int objectCount = 0;
// 3. 缓存数据
static Map<String, Object> cache = new HashMap<>();
// 4. 配置信息
static Properties config = new Properties();
// 5. 单例对象
static StaticVariableScenarios instance = new StaticVariableScenarios();
}
❌ 不适合使用static的场景
public class WrongStaticUsage {
static String name; // ❌ 错误：每个对象的姓名应该不同
static int age; // ❌ 错误：每个对象的年龄应该不同
static double salary; // ❌ 错误：每个员工的工资应该不同
// 正确的做法：这些是对象的特有数据，不应该用static修饰
private String name; // ✅ 实例变量
private int age; // ✅ 实例变量
private double salary; // ✅ 实例变量
}
2. 何时使用静态方法？
使用原则：当方法内部没有访问非静态数据时，可以定义成静态方法。
✅ 适合使用static的方法
public class StaticMethodScenarios {
// 1. 工具方法
public static String formatCurrency(double amount) {
return String.format("$%.2f", amount);
}
// 2. 数学计算
public static double calculateDistance(double x1, double y1, double x2, double y2) {
return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
}
// 3. 验证方法
public static boolean isValidEmail(String email) {
return email != null && email.contains("@") && email.contains(".");
}
// 4. 工厂方法
public static List<String> createStringList() {
return new ArrayList<>();
}
// 5. 单例获取方法
public static StaticMethodScenarios getInstance() {
return new StaticMethodScenarios();
}
}
❌ 不适合使用static的方法
public class WrongStaticMethod {
private String name;
private List<String> items = new ArrayList<>();
// ❌ 错误：访问了实例变量
// public static void setName(String name) {
// this.name = name; // 编译错误
// }
// ✅ 正确：实例方法访问实例变量
public void setName(String name) {
this.name = name;
}
// ❌ 错误：访问了实例变量
// public static void addItem(String item) {
// items.add(item); // 编译错误
// }
// ✅ 正确：实例方法访问实例变量
public void addItem(String item) {
items.add(item);
}
}
静态应用实例
1. 工具类设计
Arrays工具类示例
public class ArrayUtils {
// 私有构造函数，防止实例化
private ArrayUtils() {
throw new AssertionError("工具类不应该被实例化");
}
// 静态方法：数组转字符串
public static String arrayToString(int[] array) {
if (array == null) return "null";
if (array.length == 0) return "[]";
StringBuilder sb = new StringBuilder("[");
for (int i = 0; i < array.length; i++) {
sb.append(array[i]);
if (i < array.length - 1) sb.append(", ");
}
sb.append("]");
return sb.toString();
}
// 静态方法：查找最大值
public static int findMax(int[] array) {
if (array == null || array.length == 0) {
throw new IllegalArgumentException("数组不能为空");
}
int max = array[0];
for (int num : array) {
if (num > max) max = num;
}
return max;
}
// 静态方法：数组求和
public static long sum(int[] array) {
if (array == null) return 0;
long sum = 0;
for (int num : array) {
sum += num;
}
return sum;
}
}
// 使用示例
public class ToolClassDemo {
public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4, 5};
// 直接通过类名调用静态方法
System.out.println("数组: " + ArrayUtils.arrayToString(numbers));
System.out.println("最大值: " + ArrayUtils.findMax(numbers));
System.out.println("总和: " + ArrayUtils.sum(numbers));
}
}
2. 单例模式
public class Singleton {
// 私有静态实例
private static Singleton instance = null;
// 私有构造函数
private Singleton() {
System.out.println("单例对象创建");
}
// 静态方法获取实例
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
public void doSomething() {
System.out.println("单例对象执行操作");
}
}
// 饿汉式单例（线程安全）
public class EagerSingleton {
// 类加载时就创建实例
private static final EagerSingleton INSTANCE = new EagerSingleton();
private EagerSingleton() { }
public static EagerSingleton getInstance() {
return INSTANCE;
}
}
3. 常量定义
public class Constants {
// 数学常量
public static final double PI = 3.14159265359;
public static final double E = 2.71828182846;
// 应用配置常量
public static final String APP_NAME = "我的应用";
public static final String VERSION = "1.0.0";
public static final int DEFAULT_TIMEOUT = 30000;
// 状态常量
public static final int STATUS_SUCCESS = 0;
public static final int STATUS_ERROR = -1;
public static final int STATUS_PENDING = 1;
// 私有构造函数
private Constants() {
throw new AssertionError("常量类不应该被实例化");
}
}
4. 静态初始化
public class StaticInitialization {
static Map<String, String> countryCodeMap;
static Properties appProperties;
// 静态代码块：复杂的静态初始化
static {
System.out.println("开始初始化静态数据...");
// 初始化国家代码映射
countryCodeMap = new HashMap<>();
countryCodeMap.put("CN", "中国");
countryCodeMap.put("US", "美国");
countryCodeMap.put("JP", "日本");
// 加载配置文件
appProperties = new Properties();
try (InputStream is = StaticInitialization.class
.getResourceAsStream("/app.properties")) {
if (is != null) {
appProperties.load(is);
}
} catch (IOException e) {
System.err.println("配置文件加载失败: " + e.getMessage());
}
System.out.println("静态数据初始化完成");
}
public static String getCountryName(String code) {
return countryCodeMap.getOrDefault(code, "未知国家");
}
public static String getProperty(String key) {
return appProperties.getProperty(key);
}
}
5. 静态工厂方法
public class Person {
private String name;
private int age;
private Person(String name, int age) {
this.name = name;
this.age = age;
}
// 静态工厂方法：更清晰的对象创建方式
public static Person createAdult(String name, int age) {
if (age < 18) {
throw new IllegalArgumentException("成年人年龄不能小于18岁");
}
return new Person(name, age);
}
public static Person createChild(String name, int age) {
if (age >= 18) {
throw new IllegalArgumentException("儿童年龄不能大于等于18岁");
}
return new Person(name, age);
}
public static Person createWithUnknownAge(String name) {
return new Person(name, 0);
}
@Override
public String toString() {
return String.format("Person{name='%s', age=%d}", name, age);
}
public static void main(String[] args) {
// 使用静态工厂方法创建对象，语义更清晰
Person adult = Person.createAdult("张三", 25);
Person child = Person.createChild("小明", 10);
Person unknown = Person.createWithUnknownAge("李四");
System.out.println(adult);
System.out.println(child);
System.out.println(unknown);
}
}
高级应用
1. 静态导入
// 静态导入：可以直接使用静态成员，无需类名前缀
import static java.lang.Math.*;
import static java.lang.System.out;
public class StaticImportDemo {
public static void main(String[] args) {
// 直接使用Math类的静态成员，无需Math.前缀
double result = sqrt(16); // 等价于 Math.sqrt(16)
double power = pow(2, 3); // 等价于 Math.pow(2, 3)
double piValue = PI; // 等价于 Math.PI
// 直接使用System.out，无需System.前缀
out.println("平方根: " + result); // 等价于 System.out.println()
out.println("幂运算: " + power);
out.println("PI值: " + piValue);
}
}
2. 静态嵌套类
public class OuterClass {
static String outerStaticVar = "外部类静态变量";
String outerInstanceVar = "外部类实例变量";
// 静态嵌套类
static class StaticNestedClass {
void display() {
System.out.println(outerStaticVar); // ✅ 可以访问外部类静态成员
// System.out.println(outerInstanceVar); // ❌ 不能访问外部类实例成员
}
}
// 内部类（非静态）
class InnerClass {
void display() {
System.out.println(outerStaticVar); // ✅ 可以访问外部类静态成员
System.out.println(outerInstanceVar); // ✅ 可以访问外部类实例成员
}
}
public static void main(String[] args) {
// 静态嵌套类的使用：不需要外部类实例
OuterClass.StaticNestedClass nested = new OuterClass.StaticNestedClass();
nested.display();
// 内部类的使用：需要外部类实例
OuterClass outer = new OuterClass();
OuterClass.InnerClass inner = outer.new InnerClass();
inner.display();
}
}
最佳实践
1. 静态成员设计原则
// ✅ 好的静态设计
public class GoodStaticDesign {
// 1. 常量使用 public static final
public static final String DEFAULT_ENCODING = "UTF-8";
// 2. 私有静态变量，提供静态方法访问
private static int instanceCount = 0;
public static int getInstanceCount() {
return instanceCount;
}
// 3. 工具方法设计为静态
public static boolean isEmpty(String str) {
return str == null || str.trim().isEmpty();
}
// 4. 线程安全的静态方法
public static synchronized void incrementCount() {
instanceCount++;
}
}
// ❌ 避免的静态设计
public class BadStaticDesign {
// 1. 避免：可变的public static变量
public static List<String> globalList = new ArrayList<>(); // 线程不安全
// 2. 避免：过度使用static
static String name; // 应该是实例变量
static int age; // 应该是实例变量
// 3. 避免：static方法访问实例变量
// public static void setName(String n) {
// name = n; // 如果name不是static，这里会编译错误
// }
}
2. 内存泄漏预防
public class MemoryLeakPrevention {
// 可能导致内存泄漏的静态集合
private static Set<Object> cache = new HashSet<>();
public static void addToCache(Object obj) {
cache.add(obj);
}
// 提供清理方法
public static void clearCache() {
cache.clear();
}
// 提供大小限制
private static final int MAX_CACHE_SIZE = 1000;
public static void addToCacheWithLimit(Object obj) {
if (cache.size() >= MAX_CACHE_SIZE) {
// 清理策略：删除最老的元素或全部清理
cache.clear();
}
cache.add(obj);
}
}
3. 线程安全考虑
public class ThreadSafeStatic {
private static volatile boolean initialized = false;
private static final Object lock = new Object();
// 线程安全的懒加载
public static void initialize() {
if (!initialized) {
synchronized (lock) {
if (!initialized) {
// 执行初始化操作
System.out.println("执行初始化...");
initialized = true;
}
}
}
}
// 线程安全的计数器
private static volatile int count = 0;
public static synchronized void increment() {
count++;
}
public static int getCount() {
return count; // volatile确保可见性
}
}
总结
static使用决策流程图
是否使用static？
├── 数据类型
│ ├── 是否为常量？ → Yes → public static final
│ ├── 是否为共享数据？ → Yes → static
│ └── 是否为对象特有数据？ → Yes → 非static
├── 方法类型
│ ├── 是否为工具方法？ → Yes → static
│ ├── 是否访问实例变量？ → Yes → 非static
│ └── 是否为纯逻辑计算？ → Yes → static
└── 代码块
├── 是否为类初始化？ → Yes → static块
└── 是否为对象初始化？ → Yes → 实例块
记忆口诀
静态优先于对象，
方法区中来存放。
共享数据用静态，
工具方法设static。
类名直接可调用，
this和super不可用。
核心要点
- static成员属于类，不属于对象
- 静态优先于对象存在
- 所有实例共享静态成员
- 静态方法不能访问非静态成员
- 静态方法不能使用this和super
- 适用于工具类、单例模式、常量定义
通过合理使用static关键字，可以设计出更加高效、清晰和可维护的Java程序。
