Introduzione
Un adattatore normalmente avvolge un altro oggetto, in modo che possa essere utilizzato in un'interfaccia per la quale non è stato progettato, ad es., quando si desidera utilizzare
interface Node {
Node parent();
Iterable<Node> children();
}
insieme a
class TreeModel {
private Node root;
// example method (stupid)
Node grandparent(Node node) {
return node.parent().parent();
}
}
e ti viene assegnata una classe come
class File {
File getParent() {...}
File[] listFiles() {...}
}
devi scrivere del FileToNodeAdapter
.
Sfortunatamente, significa che devi avvolgere ogni singolo oggetto e hai anche bisogno sia di un modo per ottenere da FileToNodeAdapter
a File
(che è banale, dato che è incorporato), ma anche da File
a FileToNodeAdapter
, che porta a creare un nuovo oggetto ogni volta o a utilizzare un po 'di Map
, che deve essere accessibile globalmente o referenziato in ogni FileToNodeAdapter
.
Il modello
Sostituisci l'interfaccia Node
di
interface NodeWorker<T> {
T parentOf(T node);
Iterable<T> childrenOf(T node);
}
e modifica il TreeModel
come
class TreeModel<T> {
private NodeWorker<T> nodeWorker;
private T root;
// example method (stupid)
T grandparent(T node) {
return nodeWorker.parentOf(nodeWorker.parentOf(node));
}
...
}
Questo modello ha un nome?
Ci sono degli svantaggi, oltre al fatto che è un po 'più prolisso e applicabile solo quando sei responsabile del codice TreeModel
?