Een composiet in PHP is een softwareontwerppatroon dat deel uitmaakt van de zogeheten “Gang of Four” ontwerpprincipes, geïntroduceerd in het beroemde boek Design Patterns: Elements of Reusable Object-Oriented Software. Het composietpatroon wordt gebruikt om objecten in boomstructuren te organiseren om hiërarchieën van onderdelen en gehelden te vertegenwoordigen. Dit patroon maakt het mogelijk om individuele objecten en composities van objecten uniform te behandelen.
In PHP, net als in andere object-georiënteerde programmeertalen, is het composietpatroon handig wanneer je werkt met objectstructuren die een deel-geheel hiërarchie volgen. Laten we eens kijken naar de kernconcepten van het composietpatroon door enkele praktische voorbeelden te geven.
- Kernconcepten
1. Component: Dit is een abstracte klasse of interface die de operationele methoden definieert die zowel door eenvoudige als samengestelde objecten moeten worden geïmplementeerd.
2. Leaf: Dit vertegenwoordigt de eindknooppunten van een boomstructuur. Een blad voert de werkelijke werkuitvoering uit en heeft geen onderliggende componenten.
3. Composite: Dit is een samengestelde component die andere componenten kan bevatten, zowel `Leaf` als andere `Composite` componenten. Het implementeert de methoden die in de `Component` interface zijn gedefinieerd en maakt het mogelijk om operaties op zijn kinderen uit te voeren.
- Voorbeeld in PHP
Hier is een eenvoudige implementatie van het composietpatroon in PHP:
```
// Component Interface
interface Graphic {
public function draw();
}
// Leaf Class – Single Object
class Circle implements Graphic {
public function draw() {
echo “Drawing Circle\n”;
}
}
// Leaf Class – Another Single Object
class Square implements Graphic {
public function draw() {
echo “Drawing Square\n”;
}
}
// Composite Class
class CompositeGraphic implements Graphic {
private $children = [];
public function draw() {
foreach ($this->children as $child) {
$child->draw();
}
}
public function add(Graphic $graphic) {
$this->children[] = $graphic;
}
public function remove(Graphic $graphic) {
$this->children = array_filter($this->children, function($child) use ($graphic) {
return $child !== $graphic;
});
}
}
// Client Code
$c1 = new Circle();
$s1 = new Square();
$composite = new CompositeGraphic();
$composite->add($c1);
$composite->add($s1);
$composite->draw(); // It will output: “Drawing Circle\nDrawing Square\n”
?>
```
- Uitleg van het Voorbeeld
1. Component Interface: Hier hebben we de interface `Graphic` gedefinieerd met een `draw()` methode. Dit zorgt ervoor dat zowel individuele objecten (`Circle`, `Square`) als samengestelde objecten (`CompositeGraphic`) dezelfde methode implementeren.
2. Leaf Classes: `Circle` en `Square` implementeren de `Graphic` interface en leveren hun eigen implementatie van de `draw()` methode.
3. Composite Class: De `CompositeGraphic` klasse implementeert ook de `Graphic` interface, maar kan meerdere `Graphic` objecten bevatten en de operatie doorgeven aan al zijn kinderen.
- Bronnen
- (https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612) door Erich Gamma, Richard Helm, Ralph Johnson, en John Vlissides.
- [PHP Official Documentation](https://www.php.net/manual/en/language.oop5.php)
- [Refactoring Guru on Composite Pattern](https://refactoring.guru/design-patterns/composite/php/example#example-0)
Dit patroon is uiterst nuttig in complexere applicaties waarin hiërarchische structuren beheerd moeten worden, omdat het een gestroomlijnde en uniforme manier biedt om zowel individuele objecten als hun composities te behandelen.
