【Java】方法隐藏 vs 方法重写

变量隐藏

在当前作用域中创建一个变量，这个变量与外部作用域中的某个变量重名，导致使用该名称时默认指向当前作用域中的变量，这种现象就称为变量隐藏。

局部变量 a 被类变量 a 隐藏。

public class Main {
	private static int a = 3;
	public static void main(String[] args) {
		int a = 4;
		System.out.println(a); // == 4
	}
}
1
2
3
4
5
6
7

A 中的 i 被 B 中的 i 隐藏。

class A {
	public int i = 22;
}

class B extends A {
	public int i = 33;
}

System.out.println(new B().i); // == 33
1
2
3
4
5
6
7
8
9

方法隐藏

方法隐藏也是类似的东西。
类 A 中的 foo() 方法被类 B 中的 foo() 方法隐藏。

public class A {
	public static void foo() { }
}

public class B extends A {
	public static void foo() { }
}
1
2
3
4
5
6
7

方法重写和方法隐藏的区别：

1. 被重写的方法会被覆盖掉，而被隐藏的方法不会。
2. 只能对实例方法重写，只能对静态方法隐藏。
3. 重写是动态绑定（late binding），即运行时确定；而隐藏是静态绑定（early binding），即编译时确定。

例

class A {
	public void message() { System.out.println("From A"); }
	public static void messageStatic() { System.out.println("Static From A"); }
}

class B extends A {
	public void message() { System.out.println("From B"); }
	public static void messageStatic() { System.out.println("Static From B"); }
}

class C extends A {
	@Override
	public void message() { System.out.println("From C"); }
	public static void messageStatic() { System.out.println("Static From C"); }
}


// 重写
(new B()).message(); // == from B
(new C()).message(); // == from C

// 即使强制转换为父类，调用的依旧是子类重写的版本
((A)new B()).message(); // == from B
((A)new C()).message(); // == from C

// 隐藏
B.messageStatic(); // == Static From B
C.messageStatic(); // == Static From C

// 转换为父类后调用的就是父类的版本
((A)new B()).messageStatic(); // == Static From A
((A)new C()).messageStatic(); // == Static From A
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

参考

Overriding vs Hiding Java - Confused - StackOverflow
Variable and Method Hiding in Java