Migliorare la coesione e l'accoppiamento delle classi

0

Mi viene fornito questo insieme di codici e ho bisogno di suggerire modi per migliorare la coesione e l'accoppiamento delle classi del codice. Ma ho pensato che queste classi siano abbastanza de-accoppiate dal momento che sembra che stiano facendo uso di eventi. E in termini di coesione, tutte le chiamate init () sono messe insieme, tutto mi sembra abbastanza giusto.

public class A
{
    private C t;
    private B g;
    public static void main(String args[]) {
        // Creates t and g.
        t = new C();
        t.init();
        g = new B();
        g.init();
        g.start(this);
    }
    pubic void update (Event e)
    {
        // Performs updating of t based on event
    }
}

public class C
{
    public C() { ... }
    public void init() { ... }
}

public class B
{
    public B() { ... }

    public void init() { ... }

    public void start(A s) {
        e = getNextEvent();
        while (e. type != Quit)
            if (e.type == updateB)
                update(e) ;
            else
                s.update(e) ;
        e = getNextEvent();
    }

    public void update(Event e) { ... }
    }
}

Ci sono ancora modi per migliorare la coesione e l'accoppiamento delle classi? Mi sembra a posto, ma penso che mi manchi qualcosa.

Grazie per eventuali suggerimenti su questo.

    
posta xenon 16.06.2011 - 20:52
fonte

3 risposte

2

L'aggiornamento di t in A è simile a quello del metodo di aggiornamento in B?

Se questo è il caso, allora puoi spostare la logica di aggiornamento in C .... ma poi noterai che B e C stanno duplicando il comportamento ... e possono essere invece 1 classe, o almeno possono implementare condivisi comportamento da una classe separata (a seconda di cosa è in 'start ()')

Riducendo l'accoppiamento a quel punto, puoi creare un'interfaccia che definisca le funzionalità di init e di aggiornamento (anche in questo caso, possibilmente 'avvia' pure ... pubblica il contenuto e potremmo riuscire a lavorarci meglio).

Mi chiedo anche cosa fa init, perché se 'start' non può essere chiamato (e non lancia un'eccezione se init non viene chiamato) finché init non viene chiamato, allora l'oggetto è possibilmente in uno stato non valido dopo costruzione. Potresti essere in grado di prendere la logica da init e metterla in 'start' o nel constuctor.

    
risposta data 16.06.2011 - 21:31
fonte
1

C e A possono essere disaccoppiati usando le interfacce.

Con così tante cose mancanti da questo è difficile dire cos'altro potrebbe essere migliorato. Coesione di solito significa una "misura" di quanto una classe sia circa una, idea solitaria.

Tenendo presente questo, è possibile che C stia facendo troppo implementando un ciclo di eventi. Si potrebbe essere propensi a creare una classe del ciclo di eventi che esegue il polling delle interfacce.

L'istruzione if in start (A) sembra una violazione abbastanza significativa del Principio di sostituzione di Liskov.

    
risposta data 16.06.2011 - 21:10
fonte
0

Senza sapere cosa dovrebbero fare le classi direi che uniamo tutte e tre e che sarà altamente coesivo senza alcun accoppiamento (almeno a livello di classe).

La Classe B sta estraendo un evento da una coda e poi li distribuisce ad A o lo gestisce da solo. Quindi la classe B distribuisce e gestisce gli eventi, questa è scarsa coesione, B sta facendo più cose. Una migliore coesione sarebbe per B solo-distribuire gli eventi. Creare una nuova classe che gestisse le maniglie B aumenterebbe la coesione.

Perché non lasciare che A e B si iscrivano agli eventi stessi? Ciò eliminerebbe la distribuzione di B come intermediario e diminuirà l'accoppiamento (B non ha bisogno di conoscere il mondo delle classi in grado di rispondere agli eventi di aggiornamento).

    
risposta data 17.06.2011 - 02:19
fonte

Leggi altre domande sui tag