Nella programmazione e progettazione di computer, il principio di responsabilità unica è un concetto che sposa l’idea che qualsiasi classe in un programma dovrebbe svolgere solo una funzione nell’applicazione più ampia. Questa idea promuove in parte alcuni degli ideali della programmazione orientata agli oggetti, come l’incapsulamento, perché un’intera classe sarà focalizzata sull’esecuzione di una singola responsabilità e farà poco affidamento su classi esterne. Allo stesso tempo, è in qualche modo antitetico ad alcuni dei concetti della prima programmazione orientata agli oggetti, perché la funzione di un singolo oggetto è disaccoppiata dai dati che l’oggetto sta gestendo, il che significa che molti oggetti in combinazione potrebbero dover essere costruiti per mantenere alcuni dati centrali. Il principio della responsabilità unica è la base per un tipo di modello di progettazione noto come design guidato dalla responsabilità.
Un esempio del principio di responsabilità unica potrebbe essere rappresentato da una cornetta telefonica tradizionale. Alcuni principi di progettazione vedrebbero il telefono come un singolo oggetto che gestisce sia l’input dalla linea telefonica che la trasmissione dell’output dall’altoparlante. In un modello di responsabilità unica, in cui un singolo oggetto dovrebbe avere una sola responsabilità, il portatile sarebbe costituito da diversi oggetti separati che svolgevano ciascuno una singola funzione, come ricevere solo input dalla linea telefonica o inviare solo i dati attraverso l’auricolare.
Uno dei vantaggi che l’utilizzo del principio di responsabilità unica rende possibile è un altissimo livello di astrazione e modularità. Nell’esempio della cornetta, è possibile modificare sia l’ingresso dalla linea telefonica sia il modo in cui il segnale viene inviato all’utente senza influenzare le classi vicine purché aderiscano allo stesso contratto per l’interfacciamento. Inoltre, la riutilizzabilità di alcuni componenti può essere molto elevata, perché ogni classe è completamente incapsulata e si basa molto poco, se non del tutto, sugli oggetti circostanti, concentrandosi invece sulla sua unica responsabilità.
Una complicazione che potrebbe creare il principio di responsabilità singola è una grande quantità di classi e oggetti che operano tutti sugli stessi dati. Ciò può significare una grande quantità di spese generali e un processo di progettazione complicato. Può anche rendere difficile il debug di un programma di grandi dimensioni, poiché una singola porzione del programma potrebbe essere costituita da migliaia di file di piccole classi.
Quando il principio della responsabilità unica viene applicato attraverso una progettazione guidata dalla responsabilità, i dati e i metodi utilizzati per manipolare i dati sono separati ai fini della progettazione. Sebbene ciò porti a una certa libertà, incapsulamento e modularità nella progettazione, può anche generare una serie di modelli e progetti intermedi che devono essere utilizzati per facilitare un certo numero di classi che tentano tutte di interagire con i dati contemporaneamente. D’altra parte, se i dati di un oggetto e i metodi utilizzati per manipolarli sono legati insieme in un singolo oggetto multi-responsabilità, allora il codice può diventare più difficile da modificare man mano che i sistemi scalano, cambiano o diventano più complessi.