Java, pattern per limitare l'utilizzo del campo nelle sottoclassi a dopo aver chiamato il metodo specifico

Che ne dici di progettare un contratto più esplicito per le sottoclassi di Sub1 ?

abstract class Base {
    public abstract void draw();
}

class Sub1 extends Base {
    @Override
    public void draw() {
        //calculate top
        int top = 10;
        //use "top"

        drawWithTop(top);
    }

    protected void drawWithTop(int top) {}
}

class Sub11 extends Sub1 {
    @Override
    protected void drawWithTop(int top) {
        // you are in the "draw" context
        // use your top here
    }
}

I want to extend class Base which is defined in specific API and the extend the extended again.

Ugg, per favore non farlo. Le catene di ereditarietà lunghe causano problemi yo yo . Usa l'ereditarietà se devi entrare nell'API, ma una volta entrato non continuare a utilizzarlo più e più volte. Composizione dei preferiti .

recalculating top in draw() of Sub11 but I think it violates DRY

Sub11 ha una ragione diversa per calcolare top come fa? DRY dovrebbe essere mitigato tenendo conto del principio di singola responsabilità . La definizione moderna di cui è responsabile è una sola fonte di cambiamento. Un po 'più vecchio di saggezza in questo senso proviene da Matteo 6:24 "nessuno può servire due padroni". Non forzare top da calcolare in un posto se ci sono due diversi motivi per calcolare top certi modi che sembrano identici al momento. Non ripetere te stesso non riguarda ciò che scrivi con la tastiera. Riguarda cosa intendi.

extracting top as a field

.. è una pessima idea se significa che devi scrivere commenti come

Do not use before calling "draw()"

La soluzione semplice consiste nel fermare il caching del calcolo come effetto collaterale di draw()

class Sub1 extends Base{
    @Override
    public void draw() {
        //calculate top somewhere else
        int top = calculateTop();
        //use "top"
    }

    public int calculateTop() {
        return 10; //If the calculation is expensive and needed often cache it here
    }
}

Prima di tutto, sei sicuro che usare la doppia ereditarietà sia la strada giusta? In genere, è preferibile utilizzare invece la composizione:

abstract class Base {
    public abstract void draw();
}

class Sub1 extends Base {
    @Override
    public void draw() {
        // draw Sub1 stuff
    }
}

class Sub2 extends Base {

   private Base sub1 = new Sub1();

    @Override
    public void draw() {
        this.sub1.draw()
        // draw other sub2 stuff
    }
}

Per quanto riguarda ciò che fai con 'top', dipende da come viene usato esattamente e da cosa dipende. Se è qualcosa determinato dal codice che usa Sub1, come qualcosa che determina dove posizionarlo su una tela o finestra, allora può essere impostato usando un argomento costruttore:

abstract class Base {
    public abstract void draw();
}

class Sub1 extends Base {

    private int top;

    public Sub1(int top) {
       this.top = top;
    }
    @Override
    public void draw() {
        // draw Sub1 stuff using top
    }
}

class Sub2 extends Base {

    private int top;
    private Base sub1;

    public Sub2() {
        this.top = 10; // compute top
        this.sub1 = new Sub1(this.top);
    }

    @Override
    public void draw() {
        this.sub1.draw()
        // draw other sub2 stuff
    }
}

Se 'top' è qualcosa che è determinato da Sub1 stesso, come se fosse calcolato in base ad altre proprietà di Sub1, allora potresti usare un metodo per recuperarlo. Puoi aggiungere un metodo top a Base, aggiungerlo a Sub1 o creare una sottoclasse interface / abstract per le cose con un top. Uno di quelli probabilmente ha più senso dato la tua situazione.

A meno che non ci siano ovviamente altre classi con una proprietà 'top' simile che si intende utilizzare, vorrei semplicemente creare un metodo su Sub1 e non andare fuori bordo con la creazione di una gerarchia di tipi complicata. Sarebbe banale aggiungere una interfaccia HasTop in un secondo momento se si scopre che si finisce per aggiungerlo perché non infrange alcun codice già usando Sub1.

abstract class Base {
    public abstract void draw();
}

class Sub1 extends Base {

    private int top = 10;

    @Override
    public void draw() {
        // draw Sub1 stuff using top
    }

    public void top() {
        return this.top;
    }
}

class Sub2 extends Base {

    private Sub1 sub1 = new Sub1();

    @Override
    public void draw() {
        this.sub1.draw()
        int top = this.sub1.top();
        // draw other sub2 stuff
    }
}