Immutability vs state change in a class

Question

I'm fairly new to the concept of immutable classes. Consider this class:

public class ConnectionMonitor implements MessageConsumer {

    private final MonitorObject monitorObject;
    private boolean isConnected = true;

    private final static Logger logger = LogManager.getLogger(ConnectionMonitor.class);

    public ConnectionMonitor(final MonitorObject monitorObject) {
        this.monitorObject = monitorObject;
    }

    public boolean isConnected() {
        return isConnected;
    }

    public void waitForReconnect() {
        logger.info("Waiting for connection to be reestablished...");
        synchronized (monitorObject) {
            enterWaitLoop();
        }
    }

    private void enterWaitLoop() {
        while (!isConnected()) {
            try {
                monitorObject.wait();
            } catch (final InterruptedException e) {
                logger.error("Exception occured while waiting for reconnect! Message: " + e.getMessage());
            }
        }
    }

    private void notifyOnConnect() {
        synchronized (monitorObject) {
            monitorObject.notifyAll();
        }
    }

    @Override
    public void onMessage(final IMessage message) {
        if (message.getType() == IMessage.Type.CONNECTION_STATUS) {
            final String content = message.getContent();
            logger.info("CONNECTION_STATUS message received. Content: " + content);
            processConnectionMessageContent(content);
        }
    }

    private void processConnectionMessageContent(final String messageContent) {
        if (messageContent.contains("Disconnected")) {
            logger.warn("Disconnected message received!");
            isConnected = false;
        } else if (messageContent.contains("Connected")) {
            logger.info("Connected message received.");
            isConnected = true;
            notifyOnConnect();
        }
    }
}

I'm trying to understand how this class could be changed to an immutable one.

In particular, I don't see how the boolean field isConnected could be made final, since it represents the connection state.

All clients of ConnectionMonitor should just query isConnected() to get the connection state.

I'm aware that locking changes to isConnected is possible or using an atomic boolean.

But I don't see how to rewrite this to an immutable class.

Answer 1

The ideal is to minimize mutability -- not eliminate it.

Immutable objects have multiple advantages. They're simple, thread-safe and may be shared freely.

However, sometimes we need mutability.

In "Effective Java," Joshua Bloch suggests these guidelines:

• Classes should be immutable unless there's a very good reason to make them mutable.
• If a class cannot be made immutable, limit its mutability as much as possible.

In your example, there's a very good reason for instances of the class to be mutable. But you can also see the second guideline in play: the field monitorObject is marked final.