1. 问题背景与现象分析
在java面向对象编程中，特别是在实现如依赖反转原则（dip）等设计模式时，开发者可能会遇到条件判断逻辑不按预期工作的问题。一个常见的场景是，当父类和子类中存在同名成员变量时，子类对该变量的修改似乎并未反映到父类引用上，导致基于父类引用的条件判断始终得到错误的结果。
例如，考虑一个智能家居开关系统：一个抽象的Switchable接口定义了可开关设备的通用行为和状态，Lamp和Television是其具体实现。PowerSwitch类负责通过Switchable引用来控制设备开关。预期行为是，每次调用ClickSwitch()方法，设备状态都会在“开”和“关”之间切换。然而，实际运行时，无论调用多少次ClickSwitch()，设备状态似乎都停留在初始的“关”状态，输出始终是“lamp's off”。
初始的代码结构可能如下所示：
// State 枚举
public enum State {
on, off;
}
// 抽象父类 Switchable
public abstract class Switchable {
public State state; // 父类声明的state变量
abstract public void turn_on();
abstract public void turn_off();
}
// 子类 Lamp
public class Lamp extends Switchable {
public State state; // 子类重新声明的state变量
public Lamp() {
state = State.off;
}
public void turn_on() {
this.state = State.on; // 修改的是子类的state
System.out.println("lamp's on");
}
public void turn_off() {
this.state = State.off; // 修改的是子类的state
System.out.println("lamp's off");
}
}
// 子类 Television (存在与Lamp类似的问题，且打印信息不准确)
public class Television extends Switchable {
public State state; // 子类重新声明的state变量
public Television() {
state = State.off;
}
public void turn_on() {
this.state = State.on; // 修改的是子类的state
System.out.println("lamp's on"); // 错误：应为television's on
}
public void turn_off() {
this.state = State.off; // 修改的是子类的state
System.out.println("lamp's off"); // 错误：应为television's off
}
}
// 控制器 PowerSwitch
public class PowerSwitch {
Switchable sw;
public PowerSwitch(Switchable sw) {
this.sw = sw;
}
public void ClickSwitch() {
// 这里的sw.state访问的是Switchable中声明的state变量
if (sw.state == State.off) {
sw.turn_on();
} else {
sw.turn_off();
}
}
}
// 主程序
public class Main {
public static void main(String[] args) {
Switchable sw = new Lamp();
PowerSwitch ps = new PowerSwitch(sw);
ps.ClickSwitch(); // 第一次点击
ps.ClickSwitch(); // 第二次点击
}
}在上述代码中，预期的输出应该是“lamp's on”然后是“lamp's off”。然而，实际输出却是两次“lamp's off”。这表明PowerSwitch中的条件判断if(sw.state==State.off)始终为真，导致sw.turn_on()被调用，但sw.state却未被正确更新。
2. 问题根源：Java中的变量遮蔽（Variable Shadowing）
这个问题的核心在于Java的“变量遮蔽”（Variable Shadowing）机制。当子类声明了一个与父类中非private成员变量同名的成员变量时，子类中的这个新变量会“遮蔽”或“隐藏”父类的同名变量。这意味着：
立即学习“Java免费学习笔记（深入）”；
- 独立存储：父类和子类实际上拥有两个独立的、同名的state变量，它们在内存中是不同的存储位置。
-
访问规则：
- 在子类内部，通过this.state或直接使用state访问的是子类自己声明的变量。
- 通过父类引用（例如PowerSwitch中的sw），访问的是父类中声明的变量。
- 若要从子类内部访问被遮蔽的父类变量，需要使用super.state。
在我们的例子中：
- Switchable类声明了一个public State state;。
- Lamp和Television类也各自声明了一个public State state;。
- 当Lamp或Television的构造器被调用时，它们初始化的是子类自己的state变量。
- 当Lamp.turn_on()或Lamp.turn_off()被调用时，this.state = ...修改的也是子类自己的state变量。
- 然而，在PowerSwitch.ClickSwitch()方法中，sw是一个Switchable类型的引用。因此，if(sw.state == State.off)和sw.turn_on()/sw.turn_off()中的sw.state始终访问的是Switchable父类中声明的state变量。由于这个父类的state变量从未被子类的turn_on()或turn_off()方法修改（它们修改的是子类自己的state），它始终保持其默认值（或者未初始化时为null）。
由于Switchable父类中的state变量在Lamp对象被创建时并未被初始化，它默认为null。在PowerSwitch中，if(sw.state == State.off)将导致NullPointerException，或者如果State.off被设计为0，null == 0会是false，从而导致其他非预期行为。为了避免NullPointerException，通常会将父类变量进行默认初始化。即便如此，父类的state变量也从未被子类的方法更新。
3. 解决方案：消除变量遮蔽
解决这个问题的核心在于确保父类和子类共享同一个状态变量，而不是各自拥有独立的变量。正确的做法是，只在父类Switchable中声明state变量，并让所有子类继承并使用这个唯一的变量。
具体步骤如下：
- 在父类中初始化状态变量：在Switchable抽象类中声明并初始化state变量。这样，所有继承Switchable的子类都将拥有一个默认的off状态。
- 从子类中移除重复的变量声明：删除Lamp和Television类中state变量的声明。
- 子类直接使用继承的变量：Lamp和Television的turn_on()和turn_off()方法将直接操作从Switchable继承而来的state变量。
4. 代码示例：修正后的实现
以下是修正后的代码：
// State 枚举 (保持不变)
public enum State {
on, off;
}
// 抽象父类 Switchable (state变量在此处声明并初始化)
public abstract class Switchable {
public State state = State.off; // 统一在此处初始化
abstract public void turn_on();
abstract public void turn_off();
}
// 子类 Lamp (移除重复的state变量声明)
public class Lamp extends Switchable {
// 不再声明 public State state;
public Lamp() {
// 构造器无需再初始化state，它已在父类中初始化
}
@Override // 明确表示覆盖父类方法
public void turn_on() {
this.state = State.on; // 直接使用继承的state变量
System.out.println("lamp's on");
}
@Override // 明确表示覆盖父类方法
public void turn_off() {
this.state = State.off; // 直接使用继承的state变量
System.out.println("lamp's off");
}
}
// 子类 Television (移除重复的state变量声明，并修正打印信息)
public class Television extends Switchable {
// 不再声明 public State state;
public Television() {
// 构造器无需再初始化state
}
@Override // 明确表示覆盖父类方法
public void turn_on() {
this.state = State.on; // 直接使用继承的state变量
System.out.println("television's on"); // 修正打印信息
}
@Override // 明确表示覆盖父类方法
public void turn_off() {
this.state = State.off; // 直接使用继承的state变量
System.out.println("television's off"); // 修正打印信息
}
}
// 控制器 PowerSwitch (保持不变，因为其逻辑是正确的，问题在于变量遮蔽)
public class PowerSwitch {
Switchable sw;
public PowerSwitch(Switchable sw) {
this.sw = sw;
}
public void ClickSwitch() {
// 这里的sw.state现在访问的是Switchable中声明的唯一state变量
if (sw.state == State.off) {
sw.turn_on();
} else {
sw.turn_off();
}
}
}
// 主程序 (保持不变)
public class Main {
public static void main(String[] args) {
Switchable lamp = new Lamp();
PowerSwitch lampSwitch = new PowerSwitch(lamp);
System.out.println("Testing Lamp:");
lampSwitch.ClickSwitch(); // 第一次点击：从off -> on
lampSwitch.ClickSwitch(); // 第二次点击：从on -> off
lampSwitch.ClickSwitch(); // 第三次点击：从off -> on
System.out.println("\nTesting Television:");
Switchable tv = new Television();
PowerSwitch tvSwitch = new PowerSwitch(tv);
tvSwitch.ClickSwitch(); // 第一次点击：从off -> on
tvSwitch.ClickSwitch(); // 第二次点击：从on -> off
}
}修正后的输出示例：
Testing Lamp: lamp's on lamp's off lamp's on Testing Television: television's on television's off
现在，每次调用ClickSwitch()方法，sw.state都会正确地反映设备的当前状态，从而实现预期的开关逻辑。
5. 最佳实践与注意事项
- 避免变量遮蔽：在绝大多数继承场景中，应尽量避免变量遮蔽。它通常会导致混淆和难以调试的错误，因为它破坏了多态性在字段层面的直观预期。多态性主要应用于方法，而非字段。
- 利用IDE警告：现代IDE（如IntelliJ IDEA、Eclipse）通常会对变量遮蔽发出警告。当子类中声明了与父类同名的成员变量时，IDE会提示“Field 'state' hides field in 'Switchable'”，开发者应重视这些警告并进行修正。
-
区分方法重写与变量遮蔽：
- 方法重写（Method Overriding）：子类提供与父类方法具有相同签名的方法实现。这是多态性的核心，允许运行时根据对象的实际类型调用相应的方法。
- 变量遮蔽（Variable Shadowing）：子类声明与父类同名的成员变量。这与方法重写不同，它不会在运行时表现出多态行为，而是根据引用类型决定访问哪个变量。
- 访问修饰符与封装：如果父类的变量不希望被子类直接访问或修改，可以将其声明为private或protected，并提供public的getter/setter方法。这样可以更好地控制变量的访问和修改，同时避免了遮蔽问题。
- 设计原则：在设计类层次结构时，确保父类定义的成员变量真正代表了所有子类共有的属性。如果某个属性只特定于某个子类，那么它应该只在该子类中声明。
6. 总结
变量遮蔽是Java继承中一个常见的陷阱，它会导致程序逻辑与预期不符，尤其是在涉及多态引用和条件判断时。通过理解变量遮蔽的机制，并遵循在父类中统一声明和初始化共享变量的最佳实践，可以有效地避免此类问题。利用IDE的警告功能，并区分方法重写与变量遮蔽，是编写健壮、可维护Java代码的关键。
