Qual è il principio di responsabilità unica?
Nella programmazione e nella progettazione di computer, il principio di responsabilità singola è un concetto che sposa l'opinione che qualsiasi classe in un programma dovrebbe svolgere una sola 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 si concentrerà sull'esecuzione di un'unica responsabilità e avrà poca affidamento sulle classi esterne. Allo stesso tempo, è in qualche modo antitetico per alcuni dei concetti di programmazione orientata all'oggetto precoce, poiché la funzione di un singolo oggetto viene disaccoppiata dai dati che l'oggetto sta gestendo, il che significa che molti oggetti in combinazione potrebbero essere costruiti per mantenere alcuni dati centrali. Il principio di responsabilità unica è la base per un tipo di modello di progettazione noto come design guidato dalla responsabilità.
Un esempio del principio di responsabilità singola potrebbe assumere la forma di un telefono tradizionale. Alcuni principi di progettazione vedrebbero il portatile aS un singolo oggetto che gestisce sia l'input dalla linea del telefono sia la trasmissione dell'output dall'altoparlante. Secondo un singolo modello di responsabilità, in cui un singolo oggetto dovrebbe avere solo una singola responsabilità, il portatile consisterebbe in diversi oggetti separati che ciascuno ha eseguito una singola funzione, come la ricezione solo di input dalla linea del telefono o che produce solo i dati attraverso l'auricolare.
Uno dei vantaggi che l'uso del principio di responsabilità singola rende possibile è un livello molto elevato di astrazione e modularità. Nell'esempio del portatile, l'ingresso dalla linea del telefono o il modo in cui il segnale viene eliminato all'utente può essere modificato senza influire sulle classi vicine fintanto che aderiscono allo stesso contratto per l'interfaccia. Inoltre, la riusabilità di alcuni componenti può essere molto elevata, poiché ogni classe è completamente incapsulata e si basa suy poco, se non del tutto, sugli oggetti circostanti, concentrandosi invece sulla sua unica responsabilità.
Una complicazione che il principio di responsabilità singola potrebbe creare è una grande quantità di classi e oggetti che tutti operano sugli stessi dati. Ciò può significare una grande quantità di sovraccarico e un composto processo di progettazione. Può anche rendere difficile il debug di un grande programma, perché una sola parte del programma potrebbe consistere in migliaia di file di piccole classi.
Quando il principio di responsabilità singola viene applicato attraverso un design guidato dalla responsabilità, i dati e i metodi utilizzati per manipolare i dati sono separati per scopi di progettazione. Sebbene ciò porti a una certa libertà, incapsulamento e modularità nel design, può anche generare una serie di modelli e design intermedi che devono essere utilizzati per facilitare una serie di classi tutte tentate di interagire con i dati contemporaneamente. D'altra parte, se i dati di un oggetto e i metodi utilizzati per manipolare tutto sono legatilei in un singolo oggetto multi-responsabilità, quindi il codice può diventare più difficile da modificare quando la scala dei sistemi, cambiare o diventare più complessa.