Wat is het principe van enige verantwoordelijkheid?

In computerprogrammering en -ontwerp is het principe van een enkele verantwoordelijkheid een concept dat de mening omarmt 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ënteerde programmering, zoals inkapseling, omdat een hele klasse zal zijn gericht op het uitvoeren van een enkele verantwoordelijkheid en weinig afhankelijkheid zal hebben 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 hanteert, wat betekent dat veel objecten in combinatie mogelijk moeten worden geconstrueerd om enkele centrale gegevens te behouden. Het principe van een enkele verantwoordelijkheid is de basis voor een type ontwerpmodel dat bekend staat als verantwoordelijkheidsgestuurd ontwerp.

Een voorbeeld van het principe van een enkele verantwoordelijkheid kan de vorm aannemen van een traditionele telefoonhandset. Sommige ontwerpprincipes zouden de handset a zienS Een enkel object dat beide invoer van de telefoonlijn afhandelt en de verzending van de uitvoer van de luidspreker. Onder een enkel verantwoordelijkheidsmodel, waarin een enkel object slechts één verantwoordelijkheid zou moeten hebben, zou de handset bestaan ​​uit verschillende afzonderlijke objecten die elk een enkele functie uitvoerden, zoals alleen het ontvangen van input van de telefoonlijn, of alleen de gegevens door de oortelefoon uitvoert.

Een van de voordelen die het gebruik van het enkele verantwoordelijkheidsprincipe mogelijk maakt, is een zeer hoog niveau van abstractie en modulariteit. In het voorbeeld van de handset kan de invoer van de telefoonlijn of de manier waarop het signaal naar de gebruiker wordt uitgeoefend, worden gewijzigd zonder de aangrenzende klassen te beïnvloeden, zolang ze zich aan hetzelfde contract houden voor interface. Bovendien kan de herbruikbaarheid van bepaalde componenten erg hoog zijn, omdat elke klasse volledig is ingekapseld en verre isy Little, of helemaal niet, op omliggende objecten, in plaats daarvan gericht op zijn enige verantwoordelijkheid.

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

Wanneer het principe van een enkele 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 leidt tot een bepaalde vrijheid, inkapseling en modulariteit in het ontwerp, kan het ook een aantal tussenliggende patronen en ontwerpen genereren die moeten worden gebruikt om een ​​aantal klassen te vergemakkelijken die allemaal proberen met de gegevens tegelijk te communiceren. Aan de andere kant, als de gegevens van een object en de methoden die worden gebruikt om het allemaal te manipuleren, zijn gebonden om te krijgenHaar in een enkel multi-verantwoordelijkheidsobject, dan kan de code moeilijker te wijzigen worden als systeemschaal, wijzigen of complexer worden.