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 mantenereAlcuni 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 come un singolo oggetto che gestisce sia l'input dalla linea del telefono sia la trasmissione dell'uscita 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 supera solo i dati attraversoL'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, 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 il principio di responsabilità singolo 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 singola 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 manipolareI 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 manipolarli sono tutti legati insieme in un singolo oggetto multi-responsabilità, il codice può diventare più difficile da modificare come scala di sistemi, cambiare o diventare più complessi.