[OOP-Generico-Java] Pare mentali per uno switch-case

[banryu79]

Buondì,
ho una enum java scritta così:

public enum Posizione
{
        CENTRO, N, NE, E, SE, S, SW, W, NW;

        public Point asPoint()
        {
            int stepW = SCREEN.width/3;
            int stepH = SCREEN.height/3;

            Point point = new Point();
            switch (this) {
                case CENTRO:    point.setLocation(1.5*stepW, 1.5*stepH);
                break;
                case N:     point.setLocation(1.5*stepW, 0.5*stepH);
                break;
                case NE:    point.setLocation(2.5*stepW, 0.5*stepH);
                break;
                case E:     point.setLocation(2.5*stepW, 1.5*stepH);
                break;
                case SE:    point.setLocation(2.5*stepW, 2.5*stepH);
                break;
                case S:     point.setLocation(1.5*stepW, 2.5*stepH);
                break;
                case SW:    point.setLocation(0.5*stepW, 2.5*stepH);
                break;
                case W:     point.setLocation(0.5*stepW, 1.5*stepH);
                break;
                case NW:    point.setLocation(0.5*stepW, 0.5*stepH);
                break;
            }
            return point;
        }
}

Viene usata altrove, da oggetti grafici capaci di disegnarsi sullo schermo, tipo così:

// altrove...

    private void posizionaOggetti()
    {
        oggettoIniziale.centerOn(pos1.asPoint());

        Point p = pos2.asPoint();
        for (Drawable d : oggettiFinali) {
            d.centerOn(p);
        }
    }

La cosa in se funziona, ma non mi dispiacerebbe eliminare il costrutto switch-case, se possibile.

Di primo acchitto mi verrebbe da usare il polimorfismo: creo una interfaccia Posizione che come contratto dichiara un metodo "getPoint" che non prende nulla e restituisce un Point.
Ma così dovrei implementare 9 sottoclassi: una per ogni "posizione" (CENTRO, N, NE, E, SE, S , SW, W, NW).

Esiste un'alternativa?
Non è che non ci dormo la notte, lo switch può anche restare, ma mi domandavo se esistesse una soluzione della serie "semplice & elegante" a la OOP

[PGI-Bis]

Gli enumerativi possono avere un costruttore. Possono anche concretizzare interfacce ma sfortunatamente non c'è un'interfaccia alla radice dei punti quindi asPoint non è una cattiva idea. Comunque:

public enum Posizione {
    CENTRO(1.5,1.5), N(1.5,0.5), ECCETERA...

    private final Point BUFFER = new Point();
    private final int X, Y;
    Posizione(int x, int y) {
        int stepW = SCREEN.width/3;
        int stepH = SCREEN.height/3;
        X = stepW * x;
        Y = stepH * y;
    }
    public Point asPoint() { BUFFER.x = X; BUFFER.y = Y; return BUFFER; }
}

[cdimauro]

Credo basti una mappa ENUM -> (X, Y), e una volta ottenuti questi valori sarebbe sufficiente un banale point.setLocation(X, Y).

[banryu79]

@PGI-Bis:
Grazie mille, prezioso come sempre!
Sapevo della faccenda dei costruttori per gli enum type, ma non riuscivo a visualizzare il modo di utilizzarlo... grazie!

@cdmauro:
grazie del suggerimento; a livello pratico, con le enum di Java si traduce nella soluzione proposta da PGI, se non ho capito fischi per fiaschi.