Una mia domanda diversa ha a che fare con l'incapsulamento delle strutture di dati dei membri all'interno delle classi. Per comprendere meglio questa domanda, leggi questa domanda e osserva l'approccio discusso.
Uno dei ragazzi che ha risposto a quella domanda ha detto che l'approccio è buono, ma se l'ho capito correttamente - ha detto che dovrebbe esserci una classe esistente allo scopo di avvolgere la collezione, invece di una classe ordinaria che offre una numero di metodi pubblici solo per accedere alla collezione dei membri.
Ad esempio, invece di questo:
class SomeClass{
// downright exposing the concrete collection.
Things[] someCollection;
// other stuff omitted
Thing[] getCollection(){return someCollection;}
}
O questo:
class SomeClass{
// encapsulating the collection, but inflating the class' public interface.
Thing[] someCollection;
// class functionality omitted.
public Thing getThing(int index){
return someCollection[index];
}
public int getSize(){
return someCollection.length;
}
public void setThing(int index, Thing thing){
someCollection[index] = thing;
}
public void removeThing(int index){
someCollection[index] = null;
}
}
Avremo questo:
// encapsulating the collection - in a different class, dedicated to this.
class SomeClass{
CollectionWrapper someCollection;
CollectionWrapper getCollection(){return someCollection;}
}
class CollectionWrapper{
Thing[] someCollection;
public Thing getThing(int index){
return someCollection[index];
}
public int getSize(){
return someCollection.length;
}
public void setThing(int index, Thing thing){
someCollection[index] = thing;
}
public void removeThing(int index){
someCollection[index] = null;
}
}
In questo modo, la struttura interna dei dati in SomeClass può cambiare senza influenzare il codice cliente e senza forzare SomeClass per offrire molti metodi pubblici solo per accedere alla raccolta interna. CollectionWrapper invece fa.
es. se la raccolta passa da una matrice a una List , l'implementazione interna di CollectionWrapper cambia, ma il codice client rimane lo stesso.
Inoltre, CollectionWrapper può nascondere alcune cose dal codice client - ad esempio, può non consentire la mutazione alla raccolta non avendo i metodi setThing e removeThing .
Questo approccio al disaccoppiamento del codice client dalla struttura dati concreta sembra IMHO piuttosto buono.
Questo approccio è comune? Quali sono le cadute? È usato in pratica?