Programmazione
Java
Composition Design Pattern
Composite Design
Pattern in Java
• Il Composite Design Pattern è un design
pattern strutturale che consente di
comporre oggetti in strutture simili ad
alberi per rappresentare gerarchie
intere.
• Consente ai client di trattare singoli
oggetti e composizioni di oggetti in
modo uniforme.
• In altre parole, che si tratti di un
singolo oggetto o di un gruppo di
oggetti (compositi), i client possono
usarli in modo intercambiabile.
Componenti
del
Composite
Design
Pattern
Component
• Il component dichiara l'interfaccia per gli oggetti nella composizione
e per accedere e gestire i suoi componenti figlio.
• è come un progetto che ci dice cosa dovrebbero essere in grado di
fare sia i singoli oggetti (foglie/leaf) che i gruppi di oggetti
(compositi/composite).
• Elenca le cose che hanno tutti in comune.
Foglia
• Foglia/Leaf definisce il comportamento per gli oggetti primitivi nella
composizione.
• Questo è l'elemento costitutivo di base della composizione, che
rappresenta singoli oggetti che non hanno componenti figlio.
• Gli elementi Leaf implementano le operazioni definite dall'interfaccia
Component.
Composite
• Composite memorizza i componenti figlio e implementa le operazioni
correlate ai figli nell'interfaccia dei componenti.
• Questa è una classe che ha componenti figlio, che possono essere
elementi foglia o altri compositi.
• Una classe composita implementa i metodi dichiarati nell'interfaccia
Component, spesso delegando le operazioni ai suoi componenti
figlio.
Client
• Il client manipola gli oggetti nella composizione attraverso
l'interfaccia dei componenti.
• Il client utilizza l'interfaccia della classe dei componenti per interagire
con gli oggetti nella struttura di composizione.
• Se il destinatario è una foglia, la richiesta viene gestita direttamente.
• Se il destinatario è un composito, di solito inoltra la richiesta ai suoi
componenti figlio, eventualmente eseguendo operazioni aggiuntive prima e
dopo l'inoltro.
Esempio di
Composite Design Pattern in Java
• Costruiamo un sistema per la gestione di spedizioni, che possono
essere spedizioni semplici (di un solo oggetto) o composte da sotto-
spedizioni.
• Ogni spedizione deve poter calcolare il proprio peso, dato da:
• una tara
• il peso dell’oggetto, nel caso di una spedizione semplice
• il peso delle sotto-spedizioni di cui è composti, nel caso di spedizioni composte
Elementi di Java che ci serviranno
• Classi
• Membri privati
• Costruttori
• Metodi get/set
• Metodi pubblici
• Interfacce
• @Override
• List<Object>
Spedizione
• Rappresenta l'interfaccia public interface Spedizione {
String getId();
comune sia per le spedizioni void setId(String id);
semplici che per quelle double getTara();
void setTara(double tara);
composte. double getPeso();
}
Articolo
public class Articolo implements Spedizione {
• Rappresenta la spedizione private String id;
elementare, l’unica ad avere un private double peso;
suo peso (e una tara nulla) public Articolo(String id, double peso) {
[Link] = id;
[Link] = peso;
}
@Override
public String getId() {
return id;
}
...
}
SpedizioneComposta
• Rappresenta un insieme di spedizioni, ognuna della quale può
contenere sia articoli che altre spedizioni
• Implementa l’interfaccia Spedizione, ma contiene anche una lista di
spedizioni (List<Spedizione>)
• Definisce i metodi per aggiungere e rimuovere le spedizioni
public class SpedizioneComposta implements Spedizione {
private String id;
private double tara;
private List<Spedizione> spedizioni;
public SpedizioneComposta(String id, double tara) {
[Link] = id;
[Link] = tara;
[Link] = new ArrayList<>();
}
public void addSpedizione(Spedizione spedizione) {
[Link](spedizione);
}
public void removeSpedizione(Spedizione spedizione) {
[Link](spedizione);
}
@Override
public String getId() {
return id;
} ...
Applicazione pacco 5
tara: 0.09 kg
pacco 4
tara: 0.07 kg
• Creiamo pacco 1
tara: 0.05 kg 0.01 kg
questo caso
1.5 kg pacco 3
tara: 0.05 kg
pacco 2
tara: 0.05 kg
0.3 kg 0.03 kg 0.15 kg
Pacco 1 pacco 5
tara: 0.09 kg
pacco 4
pacco 1 tara: 0.07 kg
tara: 0.05 kg 0.01 kg
1.5 kg pacco 3
tara: 0.05 kg
pacco 2
tara: 0.05 kg
Spedizione articoloMartello = new Articolo("martello", 1.5);
SpedizioneComposta pacco1 = new SpedizioneComposta("pacco1",
0.05);
[Link](articoloMartello);
0.3 kg 0.03 kg 0.15 kg
Pacco 2 pacco 5
tara: 0.09 kg
Spedizione articoloTelefono = new Articolo("telefono", 0.3);
pacco 4
Spedizione articoloCuffie =pacco
new1 Articolo("cuffie", 0.03);
tara: 0.07 kg
SpedizioneComposta pacco2 tara: = new
0.05 kg SpedizioneComposta("pacco2", 0.05);
0.01 kg
[Link](articoloTelefono);
[Link](articoloCuffie);
1.5 kg pacco 3
tara: 0.05 kg
pacco 2
tara: 0.05 kg
0.3 kg 0.03 kg 0.15 kg
Pacco 3 pacco 5
tara: 0.09 kg
pacco 4
pacco 1 tara: 0.07 kg
tara: 0.05 kg 0.01 kg
1.5 kg pacco 3
tara: 0.05 kg
pacco 2
tara: 0.05 kg
Spedizione articoloAlimentatore = new Articolo("alimentatore", 0.15);
SpedizioneComposta pacco3 = new SpedizioneComposta("pacco3", 0.05);
[Link](articoloAlimentatore);
0.3 kg 0.03 kg 0.15 kg
Pacco 4 pacco 5
tara: 0.09 kg
pacco 4
pacco 1 tara: 0.07 kg
tara: 0.05 kg 0.01 kg
1.5 kg pacco 3
tara: 0.05 kg
pacco 2
tara: 0.05 kg
SpedizioneComposta pacco4 = new SpedizioneComposta("pacco4", 0.07);
[Link](pacco2);
[Link](pacco3);
0.3 kg 0.03 kg 0.15 kg
Pacco 5 pacco 5
tara: 0.09 kg
pacco 4
pacco 1 tara: 0.07 kg
tara: 0.05 kg 0.01 kg
Spedizione articoloFattura = new Articolo("fattura", 0.01);
SpedizioneComposta
1.5 kg pacco5 = new SpedizioneComposta("pacco5",
pacco 3 0.09);
tara: 0.05 kg
[Link](pacco1); pacco 2
[Link](pacco4); tara: 0.05 kg
[Link](articoloFattura);
0.3 kg 0.03 kg 0.15 kg