Vantaggi delle eccezioni in linguaggio di programmazione del Java

Un'eccezione è un evento, che si presenta durante l'esecuzione di un programma, che interrompe il flusso normale delle istruzioni del programma.

Vantaggio 1: Separando Errore-Maneggiando codice dal codice "normale"

Le eccezioni forniscono i mezzi per separare i particolari di che cosa fare quando qualcosa dall'ordinario accade dalla logica principale di un programma. Nella programmazione tradizionale, la rilevazione di errori, segnalare e maneggiare conducono spesso al codice confusionario degli spaghetti. Per esempio, consideri il metodo di pseudocode qui che legge un'intera lima nella memoria:

readFile {
apra la lima;
determini il relativo formato;
assegni che molta memoria;
legga la lima nella memoria;
chiuda la lima;
}

Alla prima occhiata, questa funzione sembra abbastanza semplice, ma ignora tutti gli seguenti errori potenziali:

• Che cosa accade se la lima non può essere aperta?

• Che cosa accade se la lunghezza della lima non può essere determinata?

• Che cosa accade se abbastanza memoria non può essere assegnata?

• Che cosa accade se colto viene a mancare?

• Che cosa accade se la lima non può essere chiusa?

Per maneggiare tali casi, la funzione readFile deve avere più codice per fare la rilevazione di errori, segnalante e maneggiante. Qui è un esempio di che cosa la funzione potrebbe assomigliare:

errorCodeType readFile {
inizializzi il errorCode = 0;

apra la lima;
se (theFileIsOpen) {
determini la lunghezza della lima;
se (gotTheFileLength) {
assegni che molta memoria;
se (gotEnoughMemory) {
legga la lima nella memoria;
se (readFailed) {
errorCode = -1;
}
} altrimenti {
errorCode = -2;
}
} altrimenti {
errorCode = -3;
}
chiuda la lima;
se (== 0 del errorCode del && del theFileDidntClose) {
errorCode = -4;
} altrimenti {
errorCode = errorCode e -4;
}
} altrimenti {
errorCode = -5;
}
errorCode di ritorno;
}

Ci è così tanto rilevazione di errori, segnalante e rinviante qui che le sette linee originali del codice sono perse nell'ammasso. Più difettoso ancora, il flusso logico del codice inoltre è stato perso, così rendendolo difficile dire a se il codice stia facendo la giusta cosa: La lima realmente è stata chiusa se la funzione non riesce ad assegnare abbastanza memoria? È ancor più difficile da accertarsi che il codice continui a fare la giusta cosa quando modificate il metodo tre mesi dopo scrittura esso. Molti programmatori risolvono questo problema semplicemente ignorando i iterrors sono segnalati quando i loro programmi si arrestano.

Le eccezioni vi permettono di scrivere il flusso principale del vostro codice e di occuparsi dei casi eccezionali altrove. Se la funzione readFile usasse le eccezioni anziché le tecniche tradizionali dell'errore-amministrazione, osserverebbe più come quanto segue:

readFile {
prova {
apra la lima;
determini il relativo formato;
assegni che molta memoria;
legga la lima nella memoria;
chiuda la lima;
} fermo (fileOpenFailed) {
doSomething;
} fermo (sizeDeterminationFailed) {
doSomething;
} fermo (memoryAllocationFailed) {
doSomething;
} fermo (readFailed) {
doSomething;
} fermo (fileCloseFailed) {
doSomething;
}
}

Si noti che le eccezioni non li risparmiano lo sforzo di fare il lavoro di rilevazione, di segnalazione e di maneggiamento degli errori, ma li aiutano ad organizzare efficacemente il lavoro.

Vantaggio 2: Propagazione degli errori sulla pila di chiamata

Un secondo vantaggio delle eccezioni è la capacità di propagare l'errore che segnala sulla pila di chiamata di metodi. Supponga che il metodo readFile è il metodo di quarto in serie di chiamate annidate di metodo fatte dal programma principale: method1 denomina method2, che denomina method3, che infine denomina readFile:

method1 {
chiamata method2;
}

method2 {
chiamata method3;
}

method3 {
chiamata readFile;
}

Supponga inoltre che method1 è l'unico metodo interessato agli errori che potrebbero accadere all'interno della forza tradizionale method2 e method3 di tecniche di errore-notifica di readFile. per propagare i codici di errore restituiti da alto readFile la pila di chiamata fino a che i codici di errore infine non raggiungano il metodo di method1the soltanto che sia interessato in loro:

method1 {
errore del errorCodeType;
errore = chiamata method2;
se (errore)
doErrorProcessing;
altrimenti
continui;
}

errorCodeType method2 {
errore del errorCodeType;
errore = chiamata method3;
se (errore)
errore di ritorno;
altrimenti
continui;
}

errorCodeType method3 {
errore del errorCodeType;
errore = chiamata readFile;
se (errore)
errore di ritorno;
altrimenti
continui;
}

Ricordi che l'ambiente runtime del Java cerca indietro attraverso la pila di chiamata per trovare tutti i metodi che sono interessati nel maneggiamento dell'eccezione particolare. Un metodo può duck tutte le eccezioni gettate all'interno di esso, quindi permettendo che un metodo lontano sulla pila di chiamata la interferisca. Quindi, soltanto i metodi che si preoccupano per gli errori devono preoccuparsi per la rilevazione degli errori:

method1 {
prova {
chiamata method2;
} fermo (eccezione e) {
doErrorProcessing;
}
}

method2 getta l'eccezione {
chiamata method3;
}

method3 getta l'eccezione {
chiamata readFile;
}

Tuttavia, mentre lo pseudocode mostra, ducking un'eccezione richiede un certo sforzo da parte dei metodi dell'intermediario. Tutte le eccezioni controllate che possono essere gettate all'interno di un metodo devono essere specificate nella relativa clausola dei tiri.

Vantaggio 3: Raggruppando e differenziando i tipi di errore

Poiché tutte le eccezioni gettate nell'ambito di un programma sono oggetti, il raggruppamento o la suddivisione in categorie delle eccezioni è un risultato naturale della gerarchia del codice categoria. Un esempio di un gruppo dei codici categoria relativi di eccezione nella piattaforma del Java è quelli definita in java.ioIOException e nei relativi discendenti. IOException è il più generale e rappresenta qualunque tipo di errore che può accadere quando effettua I/O. I relativi discendenti rappresentano gli errori più specifici. Per esempio, FileNotFoundException significa che una lima non potrebbe essere situata sul disc.

Un metodo può scrivere gli alimentatori specifici che possono maneggiare un'eccezione molto specifica. Il codice categoria di FileNotFoundException non ha discendenti, in modo da il seguente alimentatore può maneggiare soltanto un tipo di eccezione:

fermo (FileNotFoundException e) {
...
}

Un metodo può interferire un'eccezione basata sul relativo gruppo o tipo generale specificando c'è ne dei superclasses dell'eccezione nella dichiarazione del fermo. Per esempio, per interferire tutte le eccezioni di I/O, senza riguardo al loro tipo specifico, un alimentatore di eccezione specifica una discussione di IOException:

fermo (IOException e) {
...
}

Questo alimentatore potrà interferire tutte le eccezioni di I/O, compreso FileNotFoundException, EOFException e così via. Potete trovare i particolari circa che cosa si è presentato interrogando la discussione passata all'alimentatore di eccezione. Per esempio, usi quanto segue per stampare la traccia di pila:

interferisca (IOException e) {
e.printStackTrace(); //prodotto va a System.err.
e.printStackTrace(System.out); //trasmetta la traccia a stdout.
}

Potreste persino installare un alimentatore di eccezione che maneggia tutta l'eccezione con l'alimentatore qui:

interferisca (eccezione e) {alimentatore generale di eccezione// A (ugualmente)
...
}

Il codice categoria di eccezione è vicino alla parte superiore della gerarchia del codice categoria di THRowable. Di conseguenza, questo alimentatore interferirà molte altre eccezioni oltre che quelle che l'alimentatore è inteso per interferire. Potete desiderare maneggiare le eccezioni questo senso se tutti voi desiderano il vostro programma fare, per esempio, è la stampa verso l'esterno un messaggio di errore per l'utente ed allora rimuove.

Nella maggior parte delle situazioni, tuttavia, desiderate gli alimentatori di eccezione essere specifici come possibile. Il motivo è che la prima cosa che un mosto dell'alimentatore è determina che tipo di eccezione ha accaduto prima che possa decidere della strategia di recupero migliore. In effetti, non interferendo gli errori specifici, l'alimentatore deve accomodare tutta la possibilità. Gli alimentatori di eccezione che sono latta troppo generale rendono il codice più error-prone interferendo e maneggiando le eccezioni che non sono state previste dal programmatore e per quale l'alimentatore non è stato inteso.

Come celebre, potete generare i gruppi delle eccezioni e maneggiare le eccezioni ad un modo generale, o potete usare il tipo di eccezioni specifico per differenziare le eccezioni e maneggiare le eccezioni ad un modo esatto.

Diniego: Il nostro Web site non è responsabile delle informazioni contenute da questo articolo. Questo articolo in nessun modo riflette le viste, le opinioni, i pensieri o la credenza del personale dell'indice degli articoli.

Avviso di traduzione: L'articolo "vantaggi delle eccezioni in linguaggio di programmazione del Java" è stato tradotto usando un servizio di traduzione automatizzato. Chiediamo scusa francamente per tutti gli errori di traduzione che hanno accaduto. Grazie per capire.

Online: 737 users browsing the articles directory