Capturando exceções com escopos externos [ALGUEM ME DÁ UMA EXPLICAÇÃOZINHA]HEHE

try {   
    //... código normal   
    return;   
} catch (Exception e) {   
    //... código que trata o erro   
} finally {   
    // código executado, mesmo levantando excessão   
}

Se ocorrer um erro dentro do bloco try sera processado catch e por fim se existir o finally(Opcional) sempre sera executado, você pode ter vario catch sendo um pra cada tipo de excessão, as excessões são executadas em ordem, então se colocar uma excessão mais especifica antes de uma mais geral jamais essa especifica sera executada!

Um exemplo de excessão por exemplo por divisão por zero seria catch(ArithmeticException a) …

na verdade o que ele pediu foi:

public void doSomeThing() throws SQLException{

try{

}catch(NullPointerException e){

}

}

vc trat uma exceção no método mas lança outro tipo pra quem chamar o método tratar…

fcojj:

Capturando exceções com escopos externos
Escreva um programa que mostre um método com seu próprio bloco try não precisa capturar todo possível erro gerado dentro de try. Algumas exceções podem seguir para, e serem tratadas em, outros escopos.

PESSOAL VCS PODEM ME EXPLICAR ESSE PROBLEMA QUE O PROFESSOR DE TECNICAS DE PROGRAMAÇÃO PASSOU EU NÃO ENTENDI BEM O PROBLEMA…O QUE É ESCOPO?POR FAVOR ALGUEMN

Para ajudar caso alguém procure o tópico, segue um exemplo é claro, pois o tópico é de 5 anos atrás e nem sei se estou certo (como disse, segue para ajudar alguém que for pesquisar):

import java.util.InputMismatchException; import java.util.Scanner; public class TestaCapturaExcecoesEscoposExternos { // para as entradas do usuário private static Scanner input = new Scanner(System.in); // controla os loops para o numerador e denominador private static boolean aux; // vetor para gerar exceção private static int[] vetor; // escopo do método main public static void main(String[] args) { aux = true;// inicializa a variável booleana // estrutura de repetição do..while do { try { // obtém a entrada do numerador System.out.print( "Informe o numerador: " ); int num = input.nextInt(); // obtém a entrada do denominador System.out.print( "Informe o denominador: " ); int den = input.nextInt(); // atribui o resultado chamando o método int res = lancaPrimeira( num, den ); // exibe o resultado System.out.printf( "O resultado é: %d\n", res ); // entrada bem sucedida para divisão numerador, denominador aux = false; // valor para o tamanho do vetor System.out.print( "\nInforme o tamanho do vetor: " ); int tam = input.nextInt(); // valor para total de elementos do vetor; deve ser igual a tam System.out.print( "Quantos valores serão inseridos no vetor: " ); int tam2 = input.nextInt(); // chama o método que trata a possível exceção de tamanho e // quantidade de elementos do vetor lancaSegunda( tam, tam2 ); // trata a exceção ArithmeticException } catch ( ArithmeticException arithmeticException ) { System.err.printf( "\nException: %s\n", arithmeticException ); System.out.println( "Denominador zero é inválido, " + "tente novamente."); // trata a exceção InputMismatchException } catch ( InputMismatchException inputMismatchException ) { System.err.printf( "\nException: %s\n", inputMismatchException ); input.nextLine(); System.out.println( "Informe valores inteiros, " + "tente novamente."); } // fim da instrução do..while, que faz primeiramente as instruções e // depois testa se a variável booleana aux teve o seu valor alterado // para false } while ( aux ); } // método que realiza a divisão e pode lançar uma exceção // ArithmeticException public static int lancaPrimeira(int num, int den) throws ArithmeticException { return num / den;// possível divisão por zero } // método que carrega o vetor e seus elementos e que podem // lançar uma exceção ArrayIndexOutOfBoundsException public static void lancaSegunda( int tam, int tam2 ) throws ArrayIndexOutOfBoundsException { // atribui o valores informados no try do main e que devem ser // idênticos no escopo deste método para que não seja gerada a // exceção ArrayIndexOutOfBoundsException try { // parâmetro do método atribuído ao tamanho do vetor vetor = new int[ tam ]; // carrega o vetor com o valor informado no bloco try que // se for idêntico exibirá a impressão que está abaixo ou // caso contrário, gera um estouro de índice no vetor for ( int i = 0; i < tam2; i++ ) { vetor[ i ] = i; } // caso o valor de tam2 seja idêntico ao de tam System.out.printf( "\nÍndice\tValores\n" ); for ( int i = 0; i < vetor.length; i++ ) { System.out.printf( "%d\t%d\n", i, vetor[ i ] ); } // trata a exceção arrayIndexOutOfBoundsException } catch ( ArrayIndexOutOfBoundsException arrayIndexOutOfBoundsException ) { System.err.printf( "\nException: %s\n", arrayIndexOutOfBoundsException ); System.out.println( "Erro, estouro do índice do vetor!" ); } } }

Alguém sabe dizer se esse meu código-exemplo serve também como resposta???

package excecao31; public class Excecao { public static void main(String[] args) { try { int x = Divisao(2,0); } catch(ArithmeticException e1) { System.err.println("Erro no metodo Main!"); } } public static int Divisao(int x1, int x2) throws ArithmeticException { try { return x1/x2; } catch(ArithmeticException e1) { System.err.println("Erro no metodo Divisao!"); return 0; } } }

@wellington.nogueira

Mais uma vez, sou muito grato a vc, wellington.nogueira, pela sua resposta!

Deus abençoe a vc por tudo isso!

Vou copiar o seu código e vou estudá-lo com calma.

O meu muito obrigado!

wellington.nogueira:

cjbl:

Alguém sabe dizer se esse meu código-exemplo serve também como resposta???

Não. Seu método está tratando a exceção e nenhuma outra exceção será lançada. Apesar da assinatura do método prever isso, não ocorrerá e apenas forçará uma implementação desnecessária de um try-catch. Vamos a um exemplo: Primeiro, criei tres exceções personalizadas:

//Exceções 'personalizadas'.
class OneException extends Exception {}
class AnotherException extends Exception {}
class MoreOneException extends Exception {}

Em seguida, a classe de teste:

public class TestException {
	
	public static void main(String[] args) {
		try {
			//tentará dividir dois números fornecidos como String
			int result = divisao("10", "2"); //Lança exceção do tipo RuntimeException (unchecked)
			System.out.println("Resultado usando numeros inteiros: " + result);
		} catch (NumberFormatException e) {
			//NumberFormatException é RuntimeException e não precisa ser explicitamente 
			//declarada na assinatura do método.
			System.err.println("Erro nos parametros informados ao método: " + e.getMessage());
		}

		//Tratando exceções do tipo Exception (checked)
		try {
			testMethods(); //Lança AnotherException
		} catch (AnotherException e) {
			System.err.println("Tratando erro lançado por testMethods");
			e.printStackTrace();
		} catch (MoreOneException e) {
			System.err.println("Tratando erro lançado por testMethods");
			e.printStackTrace();
		}
		
		
	}

	private static int divisao(String strDividendo, String strDivisor) { //Veja que não há throws aqui
		try {
			int dividendo = Integer.parseInt(strDividendo); //Pode disparar NumberFormatException
			int divisor = Integer.parseInt(strDivisor);		//Pode disparar NumberFormatException
			int resultado = dividendo / divisor;			//Pode disparar ArithmeticException
			return resultado;
		} catch (ArithmeticException aex) { //Apesar de ser do tipo RuntimeException, vou tratar isto...
			System.err.println("Erro na operação de divisão: " + aex.getMessage());
		}
		return 0;
	}
	
	private static void testMethods() 
			throws AnotherException, MoreOneException { //Necessário declarar a exceção
		try {
			oneMethod();
			anotherMethod();
			moreOneMethod(); //Não farei nenhum tratamento prévio aqui...
		} catch (OneException oex) {
			System.err.println("Erro na chamada a oneMethod"); //Tratei integralmente aqui.
		} catch (AnotherException aex) {
			System.err.println("Erro na chamada a anotherMethod"); //Tratada parcialmente
			throw aex; //Deleguei o tratamento para o método chamador.
		}
	}
	
	private static void oneMethod() throws OneException {
		//Faz algo e, se necessário, lança exceção
		throw new OneException();
	}
	private static void anotherMethod() throws AnotherException {
		//Faz algo e, se necessário, lança exceção
		throw new AnotherException();
	}
	private static void moreOneMethod() throws MoreOneException {
		//Faz algo e, se necessário, lança exceção
		throw new MoreOneException();
	}

}

Agradeço também a explicação aí wellington.nogueira, obrigado!

@brunoeac

Agradeço também pelo seu código, brunoeac!

Um abraço!

cjbl:

@brunoeac

Agradeço também pelo seu código, brunoeac!

Um abraço!

Tranquilo camarada, através da sua dúvida que o wellington.nogueira enriqueceu o post, valeu!

cjbl:

Alguém sabe dizer se esse meu código-exemplo serve também como resposta???

//Exceções 'personalizadas'.
class OneException extends Exception {}
class AnotherException extends Exception {}
class MoreOneException extends Exception {}

public class TestException {
	
	public static void main(String[] args) {
		try {
			//tentará dividir dois números fornecidos como String
			int result = divisao("10", "2"); //Lança exceção do tipo RuntimeException (unchecked)
			System.out.println("Resultado usando numeros inteiros: " + result);
		} catch (NumberFormatException e) {
			//NumberFormatException é RuntimeException e não precisa ser explicitamente 
			//declarada na assinatura do método.
			System.err.println("Erro nos parametros informados ao método: " + e.getMessage());
		}

		//Tratando exceções do tipo Exception (checked)
		try {
			testMethods(); //Lança AnotherException
		} catch (AnotherException e) {
			System.err.println("Tratando erro lançado por testMethods");
			e.printStackTrace();
		} catch (MoreOneException e) {
			System.err.println("Tratando erro lançado por testMethods");
			e.printStackTrace();
		}
		
		
	}

	private static int divisao(String strDividendo, String strDivisor) { //Veja que não há throws aqui
		try {
			int dividendo = Integer.parseInt(strDividendo); //Pode disparar NumberFormatException
			int divisor = Integer.parseInt(strDivisor);		//Pode disparar NumberFormatException
			int resultado = dividendo / divisor;			//Pode disparar ArithmeticException
			return resultado;
		} catch (ArithmeticException aex) { //Apesar de ser do tipo RuntimeException, vou tratar isto...
			System.err.println("Erro na operação de divisão: " + aex.getMessage());
		}
		return 0;
	}
	
	private static void testMethods() 
			throws AnotherException, MoreOneException { //Necessário declarar a exceção
		try {
			oneMethod();
			anotherMethod();
			moreOneMethod(); //Não farei nenhum tratamento prévio aqui...
		} catch (OneException oex) {
			System.err.println("Erro na chamada a oneMethod"); //Tratei integralmente aqui.
		} catch (AnotherException aex) {
			System.err.println("Erro na chamada a anotherMethod"); //Tratada parcialmente
			throw aex; //Deleguei o tratamento para o método chamador.
		}
	}
	
	private static void oneMethod() throws OneException {
		//Faz algo e, se necessário, lança exceção
		throw new OneException();
	}
	private static void anotherMethod() throws AnotherException {
		//Faz algo e, se necessário, lança exceção
		throw new AnotherException();
	}
	private static void moreOneMethod() throws MoreOneException {
		//Faz algo e, se necessário, lança exceção
		throw new MoreOneException();
	}

}