Java静态方法覆盖真相

static 关键字含义

static 是 Java 中的一个修饰符，表示"静态的"，主要特点：

1. 属于类而非实例：静态成员属于类本身，而不是类的某个对象实例

2. 共享性：所有实例共享同一个静态成员

3. 生命周期：随着类的加载而加载，随着类的消失而消失

4. 访问方式：可以通过类名直接访问，不需要创建实例

使用场景

1. 静态变量

java

class Counter {
    static int count = 0;  // 所有实例共享
    
    Counter() {
        count++;
    }
}

// 使用
Counter c1 = new Counter();
Counter c2 = new Counter();
System.out.println(Counter.count); // 输出: 2

2. 静态方法

java

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

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

3. 静态代码块

java

class Database {
    static {
        // 类加载时执行，用于初始化静态资源
        System.out.println("数据库连接初始化...");
    }
}

关于覆盖(override)的问题

private 方法：不能覆盖

java

class Parent {
    private void privateMethod() {
        System.out.println("Parent private method");
    }
}

class Child extends Parent {
    // 这不是覆盖，只是子类自己的方法
    private void privateMethod() {
        System.out.println("Child private method");
    }
}

原因：private 方法在子类中不可见，因此无法覆盖。

static 方法：不能覆盖，但可以隐藏

java

class Parent {
    static void staticMethod() {
        System.out.println("Parent static method");
    }
}

class Child extends Parent {
    // 这不是覆盖，而是方法隐藏(method hiding)
    static void staticMethod() {
        System.out.println("Child static method");
    }
}

// 测试
Parent p = new Child();
p.staticMethod(); // 输出: Parent static method (编译时绑定)

原因：static 方法在编译时绑定（静态绑定），而不是运行时绑定（动态绑定）。

重要区别总结

特性	实例方法	静态方法
绑定时机	运行时(动态绑定)	编译时(静态绑定)
关键字	可以 override	不能 override，只能隐藏
调用方式	通过对象实例	通过类名或实例
多态性	支持多态	不支持多态

验证示例

java

public class TestOverride {
    public static void main(String[] args) {
        Parent parent = new Child();
        
        // static 方法 - 编译时绑定
        parent.staticMethod();    // 输出: Parent static method
        
        // 实例方法 - 运行时绑定
        parent.instanceMethod();  // 输出: Child instance method
    }
}

class Parent {
    static void staticMethod() {
        System.out.println("Parent static method");
    }
    
    void instanceMethod() {
        System.out.println("Parent instance method");
    }
}

class Child extends Parent {
    static void staticMethod() {
        System.out.println("Child static method");
    }
    
    @Override
    void instanceMethod() {
        System.out.println("Child instance method");
    }
}

结论：

• private 方法：不能覆盖（子类不可见）

• static 方法：不能覆盖，只能隐藏（编译时绑定）

• 只有非private的实例方法才能被真正覆盖