Porque TRY e CATCH?

Programação Java
#1

:space:
Olá pessoas, estou com uma dúvida!
Quero saber quando eu uso TRY e CATCH?
Porque eu estava fazendo uma classe Teclado e me disseram que eu preciso usar TRY e CATCH, então me veio a pergunta: POR QUÊ?
Obrigada pessoal!!!
:blackp:

#2

Você o usa quando chama algum método que lança uma exceção verificada. Dessa forma você pode tratar a exceção usando try/catch ou lançar ela novamente usando o throws na assinatura da método.
flw

#3

Por exemplo… :?:

#4

Você vai usar o tratamento de exceções quando alguma parte do código lhe obrigar. É uma forma de se precaver contra possíveis erros.

[code]String s = null;

try {
s.length();
} catch (NullPointerException e) {
System.out.println("Erro: " + e.getMessage());
}[/code]

Recomendo a leitura:
http://java.sun.com/docs/books/tutorial/essential/exceptions/

#5

Exemplo classico, tu vai conectar no banco de dados. Tu sabe se o banco de dados esta no ar?

Coloca a conexao entre try catch, se o banco nao esta no ar, uma exception sera lancada

#6

Obrigada pessoal!!! :grin:

#7

Recomendo esse texto:

http://java.sun.com/docs/books/tutorial/essential/exceptions/index.html

#8

[quote=jairelton]Recomendo esse texto:

http://java.sun.com/docs/books/tutorial/essential/exceptions/index.html[/quote]

Exatamente o link que eu passei. De qualquer forma é válido, tem sempre alguém pra ajudar a galera :wink:

#9

Um resumo meio por cima, descrevo abaixo:
As palavras reservadas da linguagem Java para o tratamento de exceções são:

  • try: indica um bloco de código no qual possam ocorrer exceções (região protegida). O “try” abre o bloco de código sobre o controle de exceções;
  • catch: associa uma exceção específica a uma região protegida. Inicia o bloco de tratamento do tipo de exceção;
  • throw: Permite a chamada/geração de uma exceção;
  • throws: Adicionado a um método para indicar que o mesmo pode ocasionar determinada exceção e não terá tratamento. O bloco de código que invocar esse método deve tratar a exceção informada pelo método invocado;
  • finally: Representa o início de bloco de código finalizador. Sempre é executado mesmo em uma exceção.

Abaixo algumas das exceções mais comuns em Java:

  • ArithmeticException: indica situações de erros em processamento aritmético, tal como uma divisão inteira por 0;
  • ArrayStoreException: Lançada para indicar que foi feita uma tentativa de armazenar o tipo errado de objeto dentro de um array de objetos. Por exemplo, o seguinte código gera uma ArrayStoreException:

Object x[] = new String[3];
x[0] = new Integer(0);

  • NullPointerException: indica que a aplicação tentou usar null onde uma referência a um objeto era necessária – invocando um método ou acessando um atributo, por exemplo;
  • NumberFormatException: indica que tentou-se a conversão de uma string para um formato numérico, mas seu conteúdo não representava adequadamente um número para aquele formato. É uma subclasse de java.lang.IllegalArgumentException;
  • StackOverflowException: Quando o Sistema Operacional fica sem espaço de armazenamento.
  • ArrayIndexOutOfBoundsException: indica a tentativa de acesso a um elemento de um arranjo fora de seus limites ou o índice era negativo ou era maior ou igual ao tamanho do arranjo. É uma subclasse de java.lang.IndexOutOfBounds, assim como a classe java.lang.StringIndexOutOfBounds;
  • ClassNotFoundException: indica que a aplicação tentou carregar uma classe mas não foi possível encontrá-la;
  • IOException : indica a ocorrência de algum tipo de erro em operações de entrada e saída. É a raiz das classes java.io.EOFException (fim de arquivo ou stream), java.io.FileNotFoundException (arquivo especificado não foi encontrado) e java.io.InterruptedIOException (operação de entrada ou saída foi interrompida), entre outras.

Exemplo da captura de uma exceção:
O código que pode lançar a exceção deve ser inserido num bloco precedido da palavra chave try;
O processador então tentará executar o bloco, até que eventualmente uma exceção seja lançada, seja por um comando contido dentro do bloco, seja por um método chamado dentro do bloco.
O bloco try descrito acima deve ser seguido de um bloco que será executado caso houver de fato lançamento de uma exceção do tipo em questão. Este bloco deve ser anunciado pela palavra chave catch seguida (entre parênteses) do tipo de exceção em questão. Se vários tipos de exceções podem ser lançadas no bloco try, deve-se fornecer um bloco catch para cada tipo de exceção. Se uma exceção do tipo em questão for lançada no bloco try, o bloco try é encerrado e a execução salta para o bloco catch apropriado. Os blocos catch são chamados manipuladores de exceções.
Ainda é possível acrescentar, após o(s) bloco(s) catch, um bloco precedido da palavra chave finally, que será executado em todos se casos, após a execução completa do bloco try ou após a execução de um bloco catch, conforme o caso.

A estrutura do código ficará da seguinte forma:

try{
// aqui vai código que pode gerar exceções dos tipos
// ExcecaoTipo1 e ExcecaoTipo2
}catch ( ExcecaoTipo1 execao1 ) {
// aqui vai código para lidar com uma exceção do tipo
// ExcecaoTipo1
}catch ( ExcecaoTipo2 execao2 ) {
// aqui vai código para lidar com uma exceção do tipo
// ExcecaoTipo2
} finally {
// aqui vai código que deve ser executado em qualquer caso
}

Quando ocorre uma exceção, os blocos catch são examinados sucessivamente até que o argumento corresponda ao tipo da exceção. Note que, no exemplo acima, se ExcecaoTipo2 for uma subclasse de ExcecaoTipo1, o segundo bloco catch nunca será alcançado. Neste caso, deve-se inverter a ordem dos blocos catch.
Um bloco catch pode também lançar novas exceções e relançar a exceção que ele manipulou. Neste caso, todo o conjunto de blocos acima deve estar inserido num bloco try mais externo e as exceções em questão devem ser manipuladas por blocos catch seguindo este bloco try externo.

:brinde:

#10