Java OOP: disaccoppiamento totale con protezione implicita

10 settembre 2012

Il disaccoppiamento (decoupling) tra le classi consente una elevata scalabilità del software, consentendo di ridurre le dipendenze tra classi differenti. Un basso grado di accoppiamento tra le classi garantisce un impatto minimo delle future modifiche e una migliore redistribuzione delle responsabilità e riusabilità delle classi: il concetto di decoupling assume allora un ruolo di primaria importanza nella progettazione software, e può essere affrontato da vari punti di vista.

Se nell’articolo precedente (“disaccoppiamento lost-identity“) abbiamo introdotto il concetto ed una strategia di implementazione, qui cercheremo di sviluppare un altro tipo di approccio al problema. Per disaccoppiare le classi il metodo migliore consiste nell’utilizzare le interfacce, l’interfaccia costituisce un elemento facade fa cioè da proxy rispetto alla classe di utilizzo.

In realtà esistono almeno due livelli di accoppiamento:

  1. accoppiamento tra classi: in tal caso le interfacce rappresentano una soluzione ottimale se non la migliore
  2. accoppiamento tra metodi: il punto 1 deve tener conto del fatto che le classi sono accoppiate con i metodi della classe target

facciamo un esempio del punto 1, creiamo una interfaccia con un metodo di prova foo():

package prova;
public interface MyInterface {
	public void foo();
}

e la classe che la implementa:

package prova;
public class Target implements MyInterface {
@Override
public void foo() {
	// TODO...
}

infine una classe di utilizzo:

package prova;
public class Source {
private MyInterface ref;
	public Source(MyInterface ref) {
		super();
		this.ref = ref;
	}
}

Quello che segue è il corrispondente diagramma UML:

uml: disaccoppiamento tramite interfacce

uml: disaccoppiamento tramite interfacce

e se volessimo modificare un metodo?

Le classi Target e Source sono disaccoppiate tra loro. Il problema però è che esiste ancora l’accoppiamento tra i metodi: supponiamo infatti di voler cambiare il nome del metodo da foo() a foo2() o, peggio ancora , di voler aggiungere (o eliminare) un metodo come nella figura seguente:

aggiunta di un metodo all'interfaccia

aggiunta di un metodo all'interfaccia

In sostanza non si può parlare ancora di disaccoppiamento totale.

Se vuoi aggiornamenti su Java OOP: disaccoppiamento totale con protezione implicita inserisci la tua e-mail nel box qui sotto:
 
X
Se vuoi aggiornamenti su Java OOP: disaccoppiamento totale con protezione implicita

inserisci la tua e-mail nel box qui sotto:

Ho letto e acconsento l'informativa sulla privacy

Acconsento al trattamento di cui al punto 3 dell'informativa sulla privacy