Java继承中的变量遮蔽：深入理解与解决方案

// 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(); // 第二次点击
    }
}

// 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