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 wordt losgekoppeld van de gegevens die het object hanteert, wat betekent dat veel objecten in combinatie mogelijk moeten worden geconstrueerd om te behoudenEnkele centrale gegevens.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 zien als een enkel object dat beide invoer van de telefoonlijn en de verzending van de uitgang van de luidspreker afhandelt.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 input ontvangen van de telefoonlijn, of alleen de gegevens uitvoert doorDe oortelefoon.

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 zeer hoog zijn, omdat elke klasse volledig is ingekapseld en zeer weinig of helemaal niet afhankelijk is van omliggende objecten, in plaats daarvan gericht op zijn enige verantwoordelijkheid.

Een complicatie die het enkele verantwoordelijkheidsprincipe kan creëren isEen 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, de gegevens en de methoden die worden gebruikt om te manipulerenDe gegevens zijn 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 samen zijn gebonden in een enkel multi-verantwoordelijkheidsobject, kan de code moeilijker te wijzigen worden als systeemschaal, verandert of complexer wordt.