manipulação de exceção Java

As exceções são alguns erros no programa, mas nem todos os erros são exceções, e às vezes os erros podem ser evitados.

Por exemplo, o código menos um ponto e vírgula, em seguida, correr para fora dos resultados é solicitar java.lang.Error errado, se você usar System.out.println (11/0), então você está fazendo, porque você usar um divisor 0 será lançada exceção java.lang.ArithmeticException.

Há muitas razões para uma exceção ocorre, geralmente contém as seguintes categorias:

• dados ilegais entrada do usuário.
• Para abrir um arquivo não existe.
• conexão de comunicação de rede for interrompida ou JVM estouro de memória.

Estas excepções, quer por causa de erro do usuário causou alguns erros processuais causada porque há outros erros físicos. -

Para entender a manipulação de exceção Java é assim que funciona, você precisa ter os seguintes três tipos de excepções:

• exceção verificada: a mais representativa verificada exceção é uma exceção devido a erro do usuário ou um problema, é o programador imprevisível. Por exemplo, quando você deseja abrir um arquivo não existe, ocorre uma exceção, a exceção não pode ser simplesmente ignorados em tempo de compilação.
• Exceção é provável que seja um programador para evitar um funcionamento anormal: em tempo de execução exceção. Em contraste com a exceção verificada, a exceção de tempo de execução pode ser ignorada em tempo de compilação.
• Erro: erro não é anormal, mas a partir da questão do controle do programador. Erro no código são geralmente ignoradas. Por exemplo, quando um estouro de pilha, ocorre um erro, eles não podem verificar em tempo de compilação.

hierarquia de classe de exceção

Todas as classes de exceção herdam subclasse java.lang.Exception.

classe de exceção é uma subclasse da classe Throwable. Além da classe de excepção, Throwable existe uma subclasse de erro.

programas Java normalmente não pegar o erro. Erro geralmente ocorre quando uma falha grave, eles são visíveis fora o processamento do programa Java.

ambiente de tempo de execução de erro usado para indicar um erro ocorre.

Por exemplo, JVM estouro de memória. Em geral, o programa não recuperar do erro.

classe de exceção tem duas subcategorias principais: classe IOException e de classe RuntimeException.

Built-in de classe Java (a próxima será explicado), que tem a maioria dos controlos habituais e exceção não verificada.

Built-in classe de exceção Java

linguagem Java define várias classes de exceção no pacote java.lang padrão.

classes de exceção de tempo de execução padrão são subclasses das classes de exceção mais comuns. Desde pacote java.lang é carregado por padrão para todos os programas em Java, então a maioria das classes de exceção de tempo de execução anomalias hereditárias pode ser usado diretamente.

De acordo com vários biblioteca de classes Java também define um número de outras excepções, a seguinte tabela lista a exceção desmarcada Java.

A tabela a seguir lista o Java definido no pacote java.lang verificada classes de exceção.

anomalia

A lista a seguir é o método principal da classe Throwable:

Capturar a exceção

Use tentar e palavras-chave de captura pode capturar a exceção. bloco try / catch em exceções lugar que possam ocorrer.

código de try / catch bloco sintaxe é chamado de um código de protecção com try / catch é a seguinte:

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

instrução catch contém uma exceção para capturar o tipo de instrução. Quando o bloco de código de proteção quando uma exceção ocorre, tente a parte de trás do bloco catch será verificada.

Se a exceção contida no bloco catch, a exceção será passado para o bloco catch, e passar um parâmetro para este método é o mesmo.

Exemplos

O exemplo a seguir declara uma matriz de dois elementos, quando o código tenta acessar o terceiro elemento da matriz quando ele vai lançar uma exceção.

// 文件名 : 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");
   }
}

A compilação e código acima executar o seguinte resultado:

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

Vários blocos catch

Uma pluralidade de blocos de código capturas após o bloco de código é chamado de uma tentativa de seguir a captura múltipla.

sintaxe bloco catch múltipla é a seguinte:

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

O trecho de código acima contém três blocos catch.

Você pode adicionar qualquer número de blocos de captura por trás da instrução try.

Se ocorrer uma exceção no código de proteção, uma exceção é lançada para o primeiro bloco catch.

Se você lançar a exceção de incompatibilidade tipo de dados de ExceptionType1, onde ele será capturado.

Se não, vai ser transferido para o segundo bloco de captura.

Então, até que a exceção é detectada por qualquer captura ou bloco.

Exemplos

Este exemplo mostra como utilizar vários 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;
}

lança / jogar Palavras-chave:

Se um método não capturar uma exceção verificada, então o método deve usar a palavra-chave para declarar joga. lança chave colocado na extremidade da assinatura do método.

Você também pode usar a palavra-chave lance lançar uma exceção, se é novo ou recém-instanciado capturado.

A seguinte declaração método lança uma exceção RemoteException:

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

Um método pode ser declarado para jogar várias exceções, separadas por uma vírgula entre várias exceções.

Por exemplo, a seguinte declaração método lança RemoteException e InsufficientFundsException:

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

finalmente, palavra-chave

finalmente, palavra-chave é usada para criar os blocos de código depois que o bloco tenta executar.

Se vai ou não ocorrer uma exceção, finalmente código de bloco de código será sempre executado.

No último bloco, você pode executar limpar o rescaldo da natureza do tipo de acabar com a declaração.

finalmente bloco apareça no bloco catch Finalmente, a sintaxe é a seguinte:

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

Exemplos

 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");
      }
   }
}

Os exemplos acima são compilados os resultados como se segue:

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

Note-se que as seguintes matérias:

• captura não pode existir independentemente da tentativa.
• No try / catch bloco não é adicionado depois de requisitos obrigatórios, finalmente.
• Não depois do bloco try catch tampouco bloco finally.
• try, catch, finalmente, não é possível adicionar qualquer código entre os blocos.

exceção personalizada declaração

Em Java, você pode personalizar exceção. Os seguintes pontos precisa se lembrar de escrever suas próprias classes de exceção.

• Todas as exceções devem ser subclasses Throwable.
• Se você quiser escrever uma classe de exceção verificada, você precisa herdar classe Exception.
• Se você quiser escrever uma classe de exceção de tempo de execução, você precisa herdar classe RuntimeException.

Você pode definir sua própria classe de exceção como este:

class MyException extends Exception{
}

Apenas classe de exceção herdam para criar classes de exceção são verificados classes de exceção.

A classe a seguir InsufficientFundsException é uma classe de exceção definida pelo usuário que herda de Exception.

Uma classe de exceção e quaisquer outras classes, contém variáveis ​​e métodos.

Exemplos

// 文件名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;
   }
}

Para demonstrar como usar a nossa classe de exceção personalizada,

No seguinte classe CheckingAccount contém um método de retirar () lança uma InsufficientFundsException exceção.

// 文件名称 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;
   }
}

O programa a seguir demonstra como chamar depósito de classe BankDemo CheckingAccount () e retirar o método ().

//文件名称 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();
      }
    }
}

Compilar os três arquivos acima, e executar o programa de BankDemo, obter os resultados da seguinte forma:

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)

exceção geral

Ele define dois tipos de exceções e erros em Java.

• JVM (Java Virtual Machine) exceção: exceção lançada pela JVM ou erros. Por exemplo: class NullPointerException, classe ArrayIndexOutOfBoundsException, ClassCastException classe.
• exceção de nível de programa: programa de API pelo programa ou lançada. Por exemplo IllegalArgumentException classe, classe IllegalStateException.