la gestione delle eccezioni Java

Le eccezioni sono alcuni errori nel programma, ma non tutti gli errori sono eccezioni, e, a volte gli errori possono essere evitati.

Ad esempio, il codice meno un punto e virgola, quindi a corto di risultati è quello di indurre java.lang.Error sbagliato, se si utilizza System.out.println (11/0), allora si sta facendo, perché si utilizza un divisore 0 esso verrà generata un'eccezione java.lang.ArithmeticException.

Ci sono molte ragioni per verifica un'eccezione, di solito contiene le seguenti categorie:

• input dell'utente dati illegali.
• Per aprire un file non esiste.
• collegamento di comunicazione di rete è overflow di memoria interrotto o JVM.

Queste eccezioni sia a causa di un errore dell'utente causato alcuni errori procedurali causate perché ci sono altri errori fisici. -

Per comprendere la gestione delle eccezioni Java è come funziona, è necessario avere i seguenti tre tipi di eccezioni:

• eccezione controllata: il più rappresentativo verificato eccezione è un'eccezione a causa di un errore dell'utente o un problema, è il programmatore imprevedibile. Per esempio quando si desidera aprire un file non esiste, si verifica un'eccezione, l'eccezione non può essere semplicemente ignorato al momento della compilazione.
• Eccezione è probabile che sia un programmatore per evitare un funzionamento anomalo: run-time eccezione. In contrasto con l'eccezione controllata, l'eccezione di runtime può essere ignorato in fase di compilazione.
• Errore: errore non è anormale, ma dalla questione del controllo del programmatore. Errore nel codice di solito sono ignorati. Ad esempio, quando si verifica un overflow dello stack un errore, non possono verificare in fase di compilazione.

gerarchia di classe Exception

Tutte le classi di eccezioni ereditano da java.lang.Exception sottoclasse.

classe Exception è una sottoclasse di classe Throwable. Oltre alla classe Exception, Throwable c'è una sottoclasse di errore.

programmi Java di solito non cattura l'errore. Errore si verifica in genere quando un difetto grave, che sono visibili al di fuori di elaborazione programma Java.

ambiente di runtime Errore utilizzato per indicare un errore si verifica.

Ad esempio, la memoria di overflow JVM. In generale, il programma non recupera dall'errore.

classe di eccezione ha due principali sottocategorie: classe IOException e di classe RuntimeException.

Built-in classe Java (la prossima sarà spiegato), che ha la maggior parte dei soliti controlli e un'eccezione incontrollato.

Built-in Java classe di eccezione

linguaggio Java definisce diverse classi di eccezioni nel pacchetto java.lang standard.

classi di eccezione di runtime standard sono sottoclassi delle classi di eccezioni più comuni. Dal momento che il pacchetto java.lang è caricato di default per tutti i programmi Java, quindi la maggior parte delle classi di eccezione di runtime anomalie ereditarie possono essere utilizzati direttamente.

Secondo varie libreria di classi Java definisce anche una serie di altre eccezioni, la seguente tabella elenca l'eccezione incontrollato Java.

La seguente tabella elenca Java definito nel pacchetto java.lang controllata classi di eccezioni.

anomalia

L'elenco che segue è la classe Throwable principale metodo:

Intercettare l'eccezione

Usa provare e parole chiave di cattura può intercettare l'eccezione. provare blocco / catch in atto le eccezioni che potrebbero verificarsi.

Sintassi di codice try / blocco catch viene chiamato un codice di protezione usando try / catch è il seguente:

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}

catch contiene un'eccezione per catturare il tipo di istruzione. Quando il blocco di codice di protezione quando si verifica un'eccezione, provare la parte posteriore del blocco catch saranno controllati.

Se l'eccezione contenuta nel blocco catch, l'eccezione viene passato al blocco catch, e passare un parametro a questo metodo è lo stesso.

Esempi

Il seguente esempio ha dichiarato un array di due elementi, quando il codice tenta di accedere al terzo elemento dell'array quando sarà un'eccezione.

// 文件名 : ExcepTest.java
import java.io.*;
public class ExcepTest{

   public static void main(String args[]){
      try{
         int a[] = new int[2];
         System.out.println("Access element three :" + a[3]);
      }catch(ArrayIndexOutOfBoundsException e){
         System.out.println("Exception thrown  :" + e);
      }
      System.out.println("Out of the block");
   }
}

Il codice di compilazione e, soprattutto, eseguire il seguente risultato:

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
Out of the block

blocchi catch multipli

Una pluralità di blocchi di codice cattura dopo il blocco di codice è chiamato una prova a seguire la cattura multipla.

sintassi blocco catch multipla è la seguente:

 try{
    // 程序代码
 }catch(异常类型1 异常的变量名1){
    // 程序代码
 }catch(异常类型2 异常的变量名2){
    // 程序代码
 }catch(异常类型2 异常的变量名2){
    // 程序代码
 }

Il frammento di codice di cui sopra contiene tre blocchi catch.

È possibile aggiungere qualsiasi numero di blocchi catch dietro l'istruzione try.

Se si verifica un'eccezione nel codice di protezione, viene generata un'eccezione al primo blocco catch.

Se si lancia l'eccezione mancata corrispondenza tipo di dati di ExceptionType1, dove verrà catturato.

In caso contrario, sarà trasferito al secondo blocco di cattura.

Quindi, fino a quando l'eccezione è catturato da qualsiasi cattura o blocco.

Esempi

Questo esempio mostra come utilizzando più try / catch.

try
{
   file = new FileInputStream(fileName);
   x = (byte) file.read();
}catch(IOException i)
{
   i.printStackTrace();
   return -1;
}catch(FileNotFoundException f) //Not valid!
{
   f.printStackTrace();
   return -1;
}

getta / tiro Parole chiave:

Se un metodo non catturare una eccezione controllata, allora il metodo deve usare la parola per dichiarare tiri. getta parola posta alla fine della firma del metodo.

È inoltre possibile utilizzare la parola chiave tiro un'eccezione, se è nuovo o appena creata un'istanza catturato.

La seguente dichiarazione di metodo genera un'eccezione RemoteException:

import java.io.*;
public class className
{
   public void deposit(double amount) throws RemoteException
   {
      // Method implementation
      throw new RemoteException();
   }
   //Remainder of class definition
}

Un metodo può essere dichiarato per gettare più eccezioni, separati da una virgola tra più eccezioni.

Ad esempio, la seguente dichiarazione metodo genera RemoteException e InsufficientFundsException:

import java.io.*;
public class className
{
   public void withdraw(double amount) throws RemoteException,
                              InsufficientFundsException
   {
       // Method implementation
   }
   //Remainder of class definition
}

infine parola chiave

infine parola chiave viene utilizzata per creare i blocchi di codice, dopo il blocco di codice tenta di eseguire.

O se non si verifica un'eccezione, viene sempre eseguito, infine, il codice blocco di codice.

Nel blocco finally, è possibile eseguire ripulire le conseguenze della natura del tipo di finire dichiarazione.

blocco finally viene visualizzato nel blocco catch Infine, la sintassi è la seguente:

 try{
    // 程序代码
 }catch(异常类型1 异常的变量名1){
    // 程序代码
 }catch(异常类型2 异常的变量名2){
    // 程序代码
 }finally{
    // 程序代码
 }
 

Esempi

 public class ExcepTest{

   public static void main(String args[]){
      int a[] = new int[2];
      try{
         System.out.println("Access element three :" + a[3]);
      }catch(ArrayIndexOutOfBoundsException e){
         System.out.println("Exception thrown  :" + e);
      }
      finally{
         a[0] = 6;
         System.out.println("First element value: " +a[0]);
         System.out.println("The finally statement is executed");
      }
   }
}

Gli esempi sopra risultati elaborati sono i seguenti:

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
First element value: 6
The finally statement is executed

Si noti che le seguenti materie:

• cattura non può esistere indipendentemente dalla prova.
• Nella try / blocco catch non viene aggiunto dopo requisiti finalmente obbligatori.
• Non dopo il blocco try fermo né ha finalmente bloccare.
• try, catch, infine, non è possibile aggiungere alcun codice tra i blocchi.

eccezione personalizzata Statement

In Java, è possibile personalizzare eccezione. I seguenti punti devono ricordarsi di scrivere le proprie classi di eccezione.

• Tutte le eccezioni devono essere sottoclassi Throwable.
• Se si vuole scrivere una classe eccezione controllata, è necessario ereditare la classe Exception.
• Se si vuole scrivere una classe un'eccezione di runtime, è necessario ereditare la classe RuntimeException.

È possibile definire la propria classe eccezione in questo modo:

class MyException extends Exception{
}

Solo classe Exception ereditano per creare classi di eccezioni vengono controllati classi di eccezioni.

La seguente classe InsufficientFundsException è una classe di eccezione definita dall'utente che eredita da Exception.

Una classe di eccezione ed eventuali altre classi, contiene variabili e metodi.

Esempi

// 文件名InsufficientFundsException.java
import java.io.*;

public class InsufficientFundsException extends Exception
{
   private double amount;
   public InsufficientFundsException(double amount)
   {
      this.amount = amount;
   } 
   public double getAmount()
   {
      return amount;
   }
}

Per dimostrare come utilizzare la nostra classe eccezione personalizzata,

Nella seguente classe CheckingAccount contiene un metodo ritirare () genera InsufficientFundsException un'eccezione.

// 文件名称 CheckingAccount.java
import java.io.*;

public class CheckingAccount
{
   private double balance;
   private int number;
   public CheckingAccount(int number)
   {
      this.number = number;
   }
   public void deposit(double amount)
   {
      balance += amount;
   }
   public void withdraw(double amount) throws
                              InsufficientFundsException
   {
      if(amount <= balance)
      {
         balance -= amount;
      }
      else
      {
         double needs = amount - balance;
         throw new InsufficientFundsException(needs);
      }
   }
   public double getBalance()
   {
      return balance;
   }
   public int getNumber()
   {
      return number;
   }
}

Il seguente programma illustra come chiamare deposito classe BankDemo CheckingAccount () e ritirare il metodo ().

//文件名称 BankDemo.java
public class BankDemo
{
   public static void main(String [] args)
   {
      CheckingAccount c = new CheckingAccount(101);
      System.out.println("Depositing $500...");
      c.deposit(500.00);
      try
      {
         System.out.println("\nWithdrawing $100...");
         c.withdraw(100.00);
         System.out.println("\nWithdrawing $600...");
         c.withdraw(600.00);
      }catch(InsufficientFundsException e)
      {
         System.out.println("Sorry, but you are short $"
                                  + e.getAmount());
         e.printStackTrace();
      }
    }
}

Compilare i tre file di cui sopra, ed eseguire il programma di BankDemo, ottenere i risultati come segue:

Depositing $500...

Withdrawing $100...

Withdrawing $600...
Sorry, but you are short $200.0
InsufficientFundsException
        at CheckingAccount.withdraw(CheckingAccount.java:25)
        at BankDemo.main(BankDemo.java:13)

eccezione generale

Si definisce due tipi di eccezioni e gli errori in Java.

• JVM (Java Virtual Machine) eccezione: eccezione generata dalla JVM o errori. Per esempio: class NullPointerException, classe ArrayIndexOutOfBoundsException, classe ClassCastException.
• eccezioni a livello di programma: il programma API dal programma o gettati. Per esempio classe IllegalArgumentException, classe IllegalStateException.