Common causes and solutions for failure of conditional judgment in Java

This article aims to help developers solve the problem of invalidity of conditional judgment statements in Java programs. By analyzing an example of the principle of dependency inversion, we explore the concept of variable shadowing in depth and provide modified code examples to ensure that the program can run as expected and achieve the correct switching of switch states.

In Java programming, we often encounter conditional judgment statements (such as if statements) that cannot work as expected. This can be caused by a variety of reasons, one of the common reasons is variable shadowing. This article will explain the concept of variable occlusion through a concrete example and provide solutions to such problems.

Variable occlusion

Variable occlusion refers to a variable with the same name as the parent class in the subclass, which causes the subclass to actually access the subclass's own variable, not the parent class's variable when accessing the variable. This can lead to logical errors, especially when the parent class variables are used for conditional judgments.

Example Analysis

The following code is an example:

 public abstract class Switchable {
    public State state;
    abstract public void turn_on(); 
    abstract public void turn_off(); 
}

public class Lamp extends Switchable {
    public State state;
    public Lamp() {
        state = State.off;
    }
    public void turn_on() {
        this.state = State.on;
        System.out.println("lamp's on");
    }
    public void turn_off() {
        this.state = State.off;
        System.out.println("lamp's off");
    }
}

public class Television extends Switchable {
    public State state;
    public Television() {
        state = State.off;
    }
    public void turn_on() {
        this.state = State.on;
        System.out.println("lamp's on");
    }
    public void turn_off() {
        this.state = State.off;
        System.out.println("lamp's off");
    }
}

public class PowerSwitch {
    Switchable sw;  
    public PowerSwitch(Switchable sw) {
        this.sw = sw;
    }
    public void ClickSwitch() {
        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();
    }
}

public enum State {
    on , off ; 
}

In this example, the Switchable class defines a state variable, and the Lamp and Television classes also define their own state variables respectively. This leads to variable occlusion. The ClickSwitch() method in the PowerSwitch class accesses the state variable of the Switchable class, while the turn_on() and turn_off() methods in the Lamp and Television classes modify their own state variables. Therefore, the conditional judgment in the PowerSwitch class is always true, resulting in the output always "lamp's off".

Solution

To resolve this problem, you need to remove the state variables in the Lamp and Television classes to make sure they are using the state variables in the Switchable class.

The modified code is as follows:

 public abstract class Switchable {
    public State state = State.off; // set up to off by default
    abstract public void turn_on(); 
    abstract public void turn_off(); 
}

public class Television extends Switchable {

    public Television(){}

    @Override
    public void turn_on() {
        this.state = State.on;
        System.out.println("television's on");
    }

    @Override
    public void turn_off() {
        this.state = State.off;
        System.out.println("television's off");
    }
}

public class Lamp extends Switchable {

    public Lamp(){}

    @Override
    public void turn_on() {
        this.state = State.on;
        System.out.println("lamp's on");
    }

    @Override
    public void turn_off() {
        this.state = State.off;
        System.out.println("lamp's off");
    }
}

In this modified code, the Lamp and Television classes no longer declare their own state variables, but directly use the state variables in the Switchable class. At the same time, in order to better distinguish, the output information of Television has also been modified. In this way, the conditional judgment in the PowerSwitch class can be correctly switched based on the state of Lamp or Television.

Things to note

• When writing Java code, be careful to avoid variable occlusion, especially in inheritance relationships.
• When using an IDE, pay attention to the warning information provided by the IDE. For example, IntelliJ IDEA will prompt variable occlusion.
• When debugging a program, you can use a debugger to check the value of a variable to determine whether there is a problem with variable occlusion.

Summarize

Variable occlusion is a common pitfall in Java programming. It may cause conditional judgments to fail, thus affecting the correctness of the program. By understanding the concept of variable occlusion and taking corresponding measures, such problems can be avoided and the quality of the code can be improved. In this case, removing the variables that are repeatedly defined in the subclass and ensuring that the subclass uses the variables of the parent class is the key to solving the problem.

The above is the detailed content of Common causes and solutions for failure of conditional judgment in Java. For more information, please follow other related articles on the PHP Chinese website!