Associatie, aggregatie en samenstelling in OOP uitgelegd

De Unified Modeling Language (UML) is een de facto standaard voor het modelleren van objectgeoriënteerde systemen. In UML zijn er vijf verschillende soorten relaties: associatie, aggregatie, samenstelling, afhankelijkheid en overerving. Dit artikel bevat een bespreking van de eerste drie van deze concepten en laat de overige over aan een andere blogpost.

Associatie in objectgeoriënteerd programmeren

Associatie is een semantisch zwakke relatie (een semantische afhankelijkheid) tussen anderszins niet-gerelateerde objecten. Een associatie is een 'gebruik'-relatie tussen twee of meer objecten waarbij de objecten hun eigen levensduur hebben en er geen eigenaar is.

Stel u bijvoorbeeld de relatie tussen een arts en een patiënt voor. Een arts kan met meerdere patiënten worden geassocieerd. Tegelijkertijd kan een patiënt meerdere artsen bezoeken voor behandeling of consultatie. Elk van deze objecten heeft zijn eigen levenscyclus en er is geen "eigenaar" of ouder. De objecten die deel uitmaken van de associatierelatie kunnen onafhankelijk worden gemaakt en vernietigd.

In UML wordt een associatierelatie weergegeven door een enkele pijl. Een associatierelatie kan worden weergegeven als een-op-een, een-op-veel of veel-op-veel (ook wel kardinaliteit genoemd). In wezen duidt een associatierelatie tussen twee of meer objecten een pad van communicatie aan (ook wel een link genoemd) tussen hen, zodat het ene object een bericht naar het andere kan sturen. Het volgende codefragment illustreert hoe twee klassen, BlogAccount en BlogEntry, aan elkaar zijn gekoppeld.

openbare klasse BlogAccount

   {

       privé BlogEntry [] blogEntries;

       // Andere leden van de BlogAccount-klasse

   }

openbare klasse BlogEntry

   {

       Int32 blogId;

       tekenreeksbijschrift;

       string tekst;

       // Andere leden van de BlogEntry-klasse

   }

Aggregatie in objectgeoriënteerd programmeren

Aggregatie is een gespecialiseerde vorm van associatie tussen twee of meer objecten waarbij elk object zijn eigen levenscyclus heeft maar er ook een eigendom bestaat. Aggregatie is een typische relatie van geheel / gedeeltelijk of ouder / kind, maar het kan al dan niet duiden op fysieke inperking. Een essentiële eigenschap van een aggregatierelatie is dat het geheel of de ouder (dwz de eigenaar) kan bestaan ​​zonder het deel of het kind en vice versa.  

Een medewerker kan bijvoorbeeld tot een of meer afdelingen in een organisatie behoren. Als de afdeling van een medewerker echter wordt verwijderd, wordt het medewerkerobject niet vernietigd maar blijft het voortleven. Merk op dat de relaties tussen objecten die deelnemen aan een aggregatie niet wederkerig kunnen zijn - dat wil zeggen, een afdeling kan een werknemer "bezitten", maar de werknemer is geen eigenaar van de afdeling. In het volgende codevoorbeeld is een aggregatierelatie duidelijk tussen de klassen BlogAuthor en BlogAccount.

openbare klasse BlogAuthor

   {

       privé Int32 authorId;

       private string voornaam;

       private string achternaam;

       // Andere leden van de BlogAuthor-klasse

   }

openbare klasse BlogAccount

   {

       privé BlogEntry [] blogEntries;

       // Andere leden van de BlogAccount-klasse

   }

Aggregatie wordt meestal weergegeven in UML met behulp van een lijn met een holle diamant. Net als bij associatie kan aggregatie een één-op-één-, één-op-veel- of veel-op-veel-relatie tussen de deelnemende objecten inhouden. In het geval van een een-op-veel- of veel-op-veel-relatie, kunnen we zeggen dat het een overtollige relatie is.

Compositie in objectgeoriënteerd programmeren

Compositie is een gespecialiseerde vorm van aggregatie. In compositie, als het bovenliggende object wordt vernietigd, houden de onderliggende objecten ook op te bestaan. Compositie is eigenlijk een sterk type aggregatie en wordt soms een "doodsrelatie" genoemd. Een huis kan bijvoorbeeld uit een of meer kamers bestaan. Als het huis wordt vernietigd, worden ook alle kamers die deel uitmaken van het huis vernietigd. Het volgende codefragment illustreert een compositierelatie tussen twee klassen, Huis en Kamer.

openbare klasse House

{

   privékamer kamer;

   openbaar huis ()

   {

       room = nieuwe kamer ();

   }

}

Net als aggregatie is compositie ook een geheel / deel- of ouder / kindrelatie. Bij de samenstelling wordt de levenscyclus van het onderdeel of kind echter bepaald door het geheel of de ouder die het bezit. Opgemerkt moet worden dat dit besturingselement direct of transitief kan zijn. Dat wil zeggen, de ouder kan direct verantwoordelijk zijn voor de creatie of vernietiging van het kind of de ouder kan een kind gebruiken dat al is gemaakt. Evenzo kan een bovenliggend object de controle delegeren aan een andere ouder om het onderliggende object te vernietigen. Compositie wordt weergegeven in UML met behulp van een lijn die de objecten verbindt met een vaste diamant aan het einde van het object dat eigenaar is van het andere object.

Ik hoop dat deze bespreking van associatie-, aggregatie- en compositierelaties je heeft geholpen te begrijpen hoe deze drie concepten verschillen. Onthoud dat aggregatie en compositie beide subsets van associatie zijn. Zowel bij aggregatie als bij samenstelling kan een object van de ene klasse de eigenaar zijn van een object van een andere klasse. En zowel bij aggregatie als bij compositie behoren de onderliggende objecten tot één enkel bovenliggend object, dwz ze kunnen slechts één eigenaar hebben.

Ten slotte zijn in een aggregatierelatie de levenscycli van bovenliggende objecten en onderliggende objecten onafhankelijk. In een compositorische relatie betekent de dood van een ouderobject ook de dood van zijn kinderen.