Wat is het beginsel van een enkele verantwoordelijkheid?

Bij computerprogrammering en -ontwerp is het principe van een enkele verantwoordelijkheid een concept dat de mening omhelst dat elke klasse in een programma slechts één functie in de grotere toepassing moet uitvoeren. Dit idee bevordert gedeeltelijk enkele van de idealen van objectgeoriënteerd programmeren, zoals inkapseling, omdat een hele klas gericht zal zijn op het uitvoeren van een enkele verantwoordelijkheid en weinig afhankelijk zal zijn van externe klassen. Tegelijkertijd is het enigszins antithetisch voor sommige concepten van vroege objectgeoriënteerde programmering, omdat de functie van een enkel object is ontkoppeld van de gegevens die het object verwerkt, wat betekent dat veel objecten in combinatie moeten worden geconstrueerd om te behouden enkele centrale gegevens. Het principe van één verantwoordelijkheid is de basis voor een type ontwerpmodel dat bekend staat als verantwoordelijkheidsgestuurd ontwerp.

Een voorbeeld van het beginsel van één verantwoordelijkheid kan de vorm aannemen van een traditionele telefoonhoorn. Sommige ontwerpprincipes zien de handset als een enkel object dat zowel invoer van de telefoonlijn als de overdracht van uitvoer van de luidspreker verwerkt. Onder een model met één verantwoordelijkheid, waarbij een enkel object slechts een enkele verantwoordelijkheid zou moeten hebben, zou de handset uit verschillende afzonderlijke objecten bestaan ​​die elk een enkele functie uitvoeren, zoals alleen invoer van de telefoonlijn ontvangen, of alleen de gegevens uitvoeren via de oortelefoon.

Een van de voordelen die het gebruik van het principe van één verantwoordelijkheid mogelijk maakt, is een zeer hoog abstractieniveau en modulariteit. In het voorbeeld van de handset kan de invoer van de telefoonlijn of de manier waarop het signaal naar de gebruiker wordt uitgevoerd, worden gewijzigd zonder de aangrenzende klassen te beïnvloeden, zolang deze zich houden aan hetzelfde contract voor interfacing. Bovendien kan de herbruikbaarheid van bepaalde componenten erg hoog zijn, omdat elke klasse volledig is ingekapseld en zeer weinig of helemaal niet afhankelijk is van omringende objecten, in plaats daarvan gericht op zijn eigen verantwoordelijkheid.

Een complicatie die het principe van een enkele verantwoordelijkheid zou kunnen creëren, is een groot aantal klassen en objecten die allemaal op dezelfde gegevens werken. Dit kan een grote hoeveelheid overhead en een ingewikkeld ontwerpproces betekenen. Het kan ook het debuggen van een groot programma bemoeilijken, omdat een enkel deel van het programma uit duizenden bestanden van kleine klassen kan bestaan.

Wanneer het principe van één verantwoordelijkheid wordt toegepast via een verantwoordelijkheidsgestuurd ontwerp, worden de gegevens en de methoden die worden gebruikt om de gegevens te manipuleren gescheiden voor ontwerpdoeleinden. Hoewel dit wel tot een zekere vrijheid, inkapseling en modulariteit in het ontwerp leidt, kan het ook een aantal tussenliggende patronen en ontwerpen genereren die moeten worden gebruikt om een ​​aantal klassen te vergemakkelijken die allemaal proberen in één keer met de gegevens te communiceren. Aan de andere kant, als de gegevens van een object en de methoden die worden gebruikt om het allemaal te manipuleren, samen zijn gebonden in één multi-verantwoordelijkheidsobject, kan de code moeilijker worden te wijzigen naarmate systemen schalen, wijzigen of complexer worden.