ByteBuffer 已经设为只读，里面的字节为什么还会变？

import java.nio.ByteBuffer;
import java.nio.ReadOnlyBufferException;
import java.util.Arrays;

public final class Main {
    private static int checks;
    private static void check(boolean ok, String message) {
        checks++;
        if (!ok) throw new AssertionError(message);
    }
    private static void rejectWrite(Runnable action) {
        try {
            action.run();
            throw new AssertionError("Expected ReadOnlyBufferException");
        } catch (ReadOnlyBufferException expected) {
            checks++;
        }
    }
    private static ByteBuffer snapshot(ByteBuffer source) {
        ByteBuffer reader = source.duplicate();
        byte[] copied = new byte[reader.remaining()];
        reader.get(copied);
        return ByteBuffer.wrap(copied).asReadOnlyBuffer();
    }
    private static String remaining(ByteBuffer source) {
        ByteBuffer reader = source.duplicate();
        byte[] content = new byte[reader.remaining()];
        reader.get(content);
        return Arrays.toString(content);
    }
    public static void main(String[] args) {
        byte[] storage = {10, 20, 30, 40};
        ByteBuffer owner = ByteBuffer.wrap(storage);
        owner.position(1).limit(3);
        ByteBuffer readOnly = owner.asReadOnlyBuffer();
        check(readOnly.isReadOnly(), "new view is read-only");
        check(readOnly.position() == 1 && readOnly.limit() == 3 && readOnly.capacity() == 4,
                "view initially copies the range state");
        check(readOnly.get() == 20, "relative get reads current position");
        check(readOnly.position() == 2 && owner.position() == 1, "positions are independent");
        System.out.println("after-view-get: owner.position=" + owner.position()
                + "; view.position=" + readOnly.position());
        owner.put(1, (byte) 99);
        storage[2] = 88;
        check(readOnly.get(1) == 99 && readOnly.get(2) == 88, "content is shared");
        System.out.println("shared: view[1]=" + readOnly.get(1) + "; view[2]=" + readOnly.get(2));
        rejectWrite(() -> readOnly.put(1, (byte) 0));
        rejectWrite(readOnly::compact);
        check(!readOnly.hasArray(), "backing array is not accessible through read-only view");
        rejectWrite(readOnly::array);
        System.out.println("view-write=ReadOnlyBufferException; compact=ReadOnlyBufferException; hasArray="
                + readOnly.hasArray());

        readOnly.clear();
        check(readOnly.position() == 0 && readOnly.limit() == 4, "read-only cursor state can change");
        check(readOnly.get(3) == 40, "old limit is not a permanent boundary");
        check(owner.position() == 1 && owner.limit() == 3, "owner range is unchanged");
        System.out.println("after-view-clear: view=" + remaining(readOnly)
                + "; owner.remaining=" + remaining(owner));

        ByteBuffer window = owner.slice().asReadOnlyBuffer();
        check(window.position() == 0 && window.limit() == 2 && window.capacity() == 2,
                "slice capacity is the original remaining length");
        window.clear();
        check(remaining(window).equals("[99, 88]"), "clear cannot expand beyond slice capacity");
        ByteBuffer fixed = snapshot(owner);
        check(owner.position() == 1, "snapshot does not consume the caller cursor");
        owner.put(1, (byte) 7);
        storage[2] = 8;
        check(remaining(window).equals("[7, 8]"), "slice still shares storage");
        check(remaining(fixed).equals("[99, 88]"), "copy does not share old storage");
        check(fixed.isReadOnly() && fixed.capacity() == 2, "snapshot exposes only copied bytes");
        System.out.println("after-owner-change: slice=" + remaining(window)
                + "; snapshot=" + remaining(fixed));
        rejectWrite(() -> fixed.put(0, (byte) 0));
        System.out.println("PASS " + checks);
    }
}