Default na Tagabuo at Pagpapanatili ng Integridad ng Klase sa Java

Kapag nagdidisenyo ng mga klase na inilaan para sa pamana (halimbawa, mga abstract na klase), itinuturing na mabuting kasanayan na huwag magpatupad ng interface Serializable, at magpasya nang paisa-isa sa bawat descendant na klase kung kailangan itong i-serialize o hindi. Gayunpaman, ang ganitong klase ay dapat magkaroon ng isang default na tagabuo upang ang mga mekanismo ng serialization ay tama na lumikha ng bagay. At kung minsan ay walang paraan upang makapagbigay ng default na tagabuo nang hindi sinisira ang integridad ng klase. Ang ganitong klase ay kadalasang dapat kunin bilang isang parameter ang ilang bagay kung wala ito ay hindi maaaring gumana nang normal, at ang pagbibigay ng default na constructor ay lalabag sa integridad ng klase. Sa ganoong sitwasyon, maaari kang magbigay ng constructor, ngunit ipagbawal ang pagtatrabaho dito hanggang sa ganap itong masimulan. Upang gawin ito, maaari mong ipasok ang isang estado sa isang klase, at payagan ang mga pamamaraan nito na tawagin lamang kung ang estado ng klase na ito ay "nasimulan". Halimbawa mula sa aklat na "Effective java" :

public abstract class AbstractFoo {
    private int x, y;

    private enum State {
        NEW, INITIALIZING, INITIALIZED
    };

    private final AtomicReference<State> init = new AtomicReference<State>(State.NEW);

    protected AbstractFoo() {}

    public AbstractFoo(int x, int y) {
        initialize(x, y);
    }

    protected final void initialize(int x, int y) {
        if (!init.compareAndSet(State.NEW, State.INITIALIZING)) {
            throw new IllegalStateException("Already initialized");
        }
        this.x = x;
        this.y = y;
        init.set(State.INITIALIZED);
    }

    protected final int getX() {
        checkInit();
        return x;
    }

    protected final int getY() {
        checkInit();
        return y;
    }

    private void checkInit() {
        if (init.get() != State.INITIALIZED) {
            throw new IllegalStateException("Uninitialized");
        }
    }
}

class Foo extends AbstractFoo implements Serializable {
    private void readObject(ObjectInputStream s) throws IOException,
            ClassNotFoundException {
        s.defaultReadObject();
        int x = s.readInt();
        int y = s.readInt();
        initialize(x, y);
    }

    private void writeObject(ObjectOutputStream s) throws IOException {
        s.defaultWriteObject();
        s.writeInt(getX());
        s.writeInt(getY());
    }

    public Foo(int x, int y) {
        super(x, y);
    }
}

Kasabay nito, dapat suriin ng lahat ng mga pamamaraan ng klase na ito ang kasalukuyang estado ng klase at maiwasan ang maling paggamit nito, at ang mga pamamaraan readObject()at dapat tukuyin sa descendant na klase writeObject(). Link sa orihinal na pinagmulan: http://0agr.ru