Reassigning a value to an instance variable inside of a method by reassigning the method argument's variable

My class has a scheduled method that runs every half a second and it checks the data to see if any of the devices have timed out. If they are timed out for at least 5 seconds I am throwing an event to my database (this is done by checkSpecs method which I haven't reproduced here. The actual class is quite large so I have attempted to reduce the size while keeping relevant parts).

Now I am adding a new method to the class, checkReconnections which I want to use to throw another event to the database whenever a connection that previously timed out is regained.

Because my class is so large and I am monitoring several devices with this method, I attempted to create a helper method monitorConnectionStatus that accepts two booleans as arguments. My question is concerning this method.

I was under the impression that in passing the instance variables into monitorConnectionStatus when the method is invoked, that method gains access to them and can reassign those variables. This is my intent in order for the method to function as intended. But my IDE is telling me that the value of disconnectionStatus will always be false, which caused me to think, am I wrong in believing the instance variable will be reassigned? Is it possible that my IDE is just wrong in this case?

When I reassign the value of disconnectionStatus is it reassigning the value of the instance variable hasADisconnected or is it just doing it with a local argument variable?

Public Class OffSpecAgent {
    private final DataModel dataModel;

    private int deviceATimeoutCounter = 0;
    private boolean isDeviceATimeout = false;
    private boolean hasADisconnected = false;

    private int deviceBTimeoutCounter = 0;
    private boolean isDeviceBTimeout = false;
    private boolean hasBDisconnected = false;

    @Scheduled(fixedDelay = 500)
    public void offSpecMonitor() {
        checkTimeouts();
        checkReconnections();
        checkSpecs();
    }

    private void checkTimeouts() {
        deviceATimeoutCounter = dataModel.getBoolean(DEVICE_A_TIMEOUT) ? deviceATimeoutCounter + 1 : 0;
        isDeviceATimeout = deviceATimeoutCounter >= 10;

        deviceBTimeoutCounter = dataModel.getBoolean(DEVICE_B_TIMEOUT) ? deviceBTimeoutCounter + 1 : 0;
        isDeviceBTimeout = deviceATimeoutCounter >= 10;
    }

    private void checkReconnections() {
        monitorConnectionStatus(isDeviceATimeout, hasADisconnected);
        monitorConnectionStatus(isDeviceBTimeout, hasBDisconnected);
    }

    private void monitorConnectionStatus(boolean timeoutCondition, boolean disconnectionStatus) {
        if (timeoutCondition) {
            disconnectionStatus = true;
        }
        if (disconnectionStatus && !timeoutCondition) {
            disconnectionStatus = false;
            //throw reconnection event
        }
    }
}

In java, variables are passed by value into methods, meaning your method monitorConnectionStatus is only aware that it's getting false, false values. You would have to update your method to access the instance variable directly.

private void monitorConnectionStatus() {
    if (this.timeoutCondition) {
        this.disconnectionStatus = true;
    }
    if (this.disconnectionStatus && !this.timeoutCondition) {
        this.disconnectionStatus = false;
        //throw reconnection event
    }
}

Note the keyword this is not required.

Also, I just want to add that you are using the term class variable incorrectly. The variables you are referring to are instance variables.

You can read more about that here:

https://www.tutorialspoint.com/What-are-class-variables-instance-variables-and-local-variables-in-Java

I refactored the class and now it looks like this:

Public Class OffSpecAgent {
private final DataModel dataModel;
private static class ConnectionTracker {
boolean timeout, timeoutExceeded, hasDisconnected;
int timeoutCounter = 0;
}
private final ConnectionTracker deviceATracker = new ConnectionTracker();
private final ConnectionTracker deviceBTracker = new ConnectionTracker();
@Scheduled(fixedDelay = 500)
public void offSpecMonitor() {
checkTimeouts();
checkReconnections();
checkSpecs();
}
private void checkTimeouts() { 
trackTimeout(plcTracker, dataModel.getBoolean(DEVICE_A_TIMEOUT), 10);
trackTimeout(plcTracker, dataModel.getBoolean(DEVICE_B_TIMEOUT), 20);
}
private void trackTimeout(ConnectionTracker tracker, boolean isTimeout, int maxTimeout){
tracker.timeout = isTimeout;
tracker.timeoutCounter = isTimeout ? tracker.timeoutCounter + 1 : 0;
tracker.timeoutExceeded = tracker.timeoutCounter >= maxTimeout;
}
private void checkReconnections() {
monitorConnectionStatus(deviceATracker);
monitorConnectionStatus(deviceBTracker);
}
private void monitorConnectionStatus(ConnectionTracker tracker) {
if (tracker.timeoutExceeded) {
tracker.hasDisconnected = true;
}
if (tracker.hasDisconnected && !tracker.timeout) {
tracker.hasDisconnected = false;
//throw reconnection event
}
}
}

This seems to be much of an improvement, the tracker object actually makes the code more readable in my opinion, and now I am able to have the desired behavior. Thank you to everyone who responded to my question.