Exercício Capturando exceções com superclasse

t

como disse talvez a explicação não esteja boa mais atente para o tipo de exceção que cada classe trata.

Olá lucas_guj,

Seguinte: 1º vc tem que criar as 3 classes testadoras de exceções, respectivamente A, que deve estender a superclasse Exception, B que estende A e C que estende B, conforme pede o exercício.

public class ExceptionA extends Exception {} public class ExceptionB extends ExceptionA {} public class ExceptionC extends ExceptionB {}

2° escrever um método que possa vir a lançar uma exceção, por exemplo, um código que solicite uma entrada de dados;

static void WriteSomeThing (String x) throws ExceptionA, ExceptionB, ExceptionC { if (x.isEmpty()) { throw new ExceptionC(); // aqui é importante que vc instâncie alguma das classes de exceção... } }

3º Vc deve capturar a exceção;

} catch (ExceptionA e) { System.out.println(e.toString()); }

Acho que é isso!! Espero ter ajudado.

lucas_guj:

Eu estou tentando fazer o exercício do deitel - 11.17 e não sei se fiz corretamente, gostaria que vocês me falassem se eu fiz certo ou não ou se tenho que trocar algo.

O enunciado: Capturando exceções com superclasses: Utilize herança para criar uma superclasse de exceção (chamada ExceptionA) e subclasses de exceção ExceptionB e ExceptionC, em que ExceptionB herda de ExceptionA e ExceptionB herda de ExceptionB. Escreva um programa para demonstrar que o bloco catch para o tipo ExceptionA captura exeções de tipos ExceptionB e ExceptionC.

Classe ExcecaoA

public class ExcecaoA
{
	public static void lancaExcecao() throws Exception
	{
		try
		{
			System.out.println( "Superclasse ExcecaoA." );
			ExcecaoB.lancaExcecaoB();
		}
		catch( Exception exception ) // não executa
		{
			System.err.println( "Captura ExcecacoB e ExcecaoC" );
		}
	}
}

Classe ExcecaoB

public class ExcecaoB extends ExcecaoA
{
	public static void lancaExcecaoB() throws Exception
	{
		try
		{
			System.out.println( "Metodo lancaExcecaoB" );
			ExcecaoC.lancaExcecaoC();
		}
		catch( Exception exception ) // não executa
		{
			System.err.println( "" );
		}
	}	
}

Classe ExcecaoC

public class ExcecaoC extends ExcecaoB
{
	public static void lancaExcecaoC() throws Exception
	{
		try
		{
			System.out.println( "Metodo lancaExcecaoC" );
			throw new Exception();
		}
		catch( Exception exception ) // não executa
		{
			System.err.println( "" );
		}
	}
}

Classe CapturaExcecoes( Programa )

public class CapturandoExcecoes
{
	public static void main( String[] args )
	{
		try
		{
			ExcecaoA.lancaExcecao();
		}
		catch( Exception exception )
		{
			System.err.println( "Metodo Main captura excecao de ExcecaoA" );
		}
	}
}

[b]
Resultado no CMD:

Superclasse ExcecaoA.
Metodo lancaExcecaoB
Metodo lancaExcecaoC[/b]

Esse negócio de exceções achei bem complicado ¬¬

lucas_guj baseado no seu exercício eu fiz isso, porém o meu não funciona acho que devido aos valores das variáveis dentro dos try catches perderem o seu valor ao sair do bloco, enfim, minha idéia não é tratar corretamente o exercício agora e sim saber como a superclasse obtém as exceções lançadas nas subclasses conforme o exercício.

import java.util.InputMismatchException;
public class ExceptionA {
    public static void lancaExcecao() throws Exception, 
    				ArithmeticException, InputMismatchException {
        try {
        	
        	ExceptionB.lancaExcecaoB();  
                ExceptionC.lancaExcecaoC(); 
        
        // trata InputMismatchException    
        } catch( InputMismatchException inputMismatchException ) {
        	
        	System.err.printf( "\nException: %s\n", inputMismatchException );
        	System.out.println( "Você não inseriu inteiros, tente novamente!" );   
            
        // trata ArithmeticException    
        } catch( ArithmeticException arithmeticException ) {
        	
        	System.err.printf( "\nException: %s\n", arithmeticException );
            System.out.println( "Zero é inválido, tente novamente!" );  
        }  
    }  
}

import java.util.InputMismatchException;
import java.util.Scanner;
public class ExceptionB extends ExceptionA {
	public static void lancaExcecaoB() throws Exception, InputMismatchException {
		Scanner input = new Scanner(System.in);
		try {

			// lançar aqui uma divisão por string
			System.out.print("Informe um valor para o numerador: ");
			int numB = input.nextInt();

			System.out.print("Informe um valor para o denominador: ");
			int denB = input.nextInt();

			int resB = numB / denB;

			System.out.println("O resultado é: " + resB);
			
			lancaExcecao();

		// não executa
		} catch ( Exception exception ) {
			
		}
	}
}

import java.util.Scanner;
public class ExceptionC extends ExceptionB {
	public static void lancaExcecaoC() throws Exception, ArithmeticException {
		Scanner input = new Scanner(System.in);
		try {

			// lançar aqui uma divisão por zero
			System.out.print("Informe um valor para o numerador: ");
			int numA = input.nextInt();

			System.out.print("Informe um valor para o denominador: ");
			int denA = input.nextInt();

			int resA = numA / denA;

			System.out.println("O resultado é: " + resA);
			
			lancaExcecaoB();

		// não executa
		} catch ( Exception exception ) {

		}
	}
}

import java.util.InputMismatchException;
public class TestaExceptions {
	public static void main(String[] args) 
			throws InputMismatchException, ArithmeticException, 
			Exception {
		ExceptionA.lancaExcecao();
	}
}

Olá Lucas, eu imagino que você não entendeu corretamente o enunciado, mas vamos por partes.

O enunciado: Capturando exceções com superclasses: Utilize herança para criar uma superclasse de exceção (chamada ExceptionA) e subclasses de exceção ExceptionB e ExceptionC, em que ExceptionB herda de ExceptionA e ExceptionC herda de ExceptionB. Escreva um programa para demonstrar que o bloco catch para o tipo ExceptionA captura exeções de tipos ExceptionB e ExceptionC.

Teremos que criar 3 classes, como já te falaram.

public class ExceptionA extends Exception
public class ExceptionB extends ExceptionA
public class ExceptionC extends ExceptionB

Eu imagino que você entenda como funciona, de forma geral as exceções, mas vamos dar uma leve revisada.

Uma exceção nada mais é que uma classe que herda Exception ou RuntimeException ou qualquer outra classes que herdam estas.
Para lançar exceções nos usamos a palavra throw. Uma exceção também contem algumas informações importantes como a mensagem de erro, ou quem foi responsável por lança-la.

Então como nos lançaríamos uma exceção

public void seuMetodo() throws SuaExceção {
   // Para lançar uma nova exceção utilize.
   throw new SuaExceção();
}

Então note que no próprio método nos já informamos que ele lança uma exceção do tipo SuaExceção, a palavra throw é utilizada para lançar esta exceção, entretanto nos não temos nenhuma exceção, então utilizamos o operador new para criar a exceção desejada.

As classes que são exceções normalmente não tem métodos para lança-las pois isso é responsabilidade de outra classe, mas para fins didáticos vamos criar estes métodos.
Cada classe então ira conter um método lancarExceção() que ira lançar uma exceção do mesmo tipo que sua classe, confuso ? Veja um exemplo

public class ExcecaoTeste extends Exception {
	
		 // Construtor que recebe uma String que contem informações sobre o erro, e chama o construtar da calsse pai (Exception) para guardar a mensagem.  
		public ExcecaoTeste(String mensagem) {
			super(mensagem);
		}
		
		// Os outros construtores também podem serem usados, desde que sejam implementados.  
		
		// Método para lançar uma exceção, vale lembrar que classes que são uma exceção normalmente não possuem tais métodos.
		public static void lancarExcecao() throws ExcecaoTeste {
			// Cria e lança uma exceção de classe ExcecaoTeste
			throw new ExcecaoTeste("Exceção lançada pela classe ExeceçãoTeste");
		}
		
	}

O que você ira fazer agora serão classes baseadas, não é para copiar e colar, no modelo. Logo após ira utilizar de polimorfismo para tratar as exceções lançadas. Isto é uma classe filha sendo usada como a pai.

Algo como:

public static void main(String[] args) {
		try {
			// Metodo para lançar exceção de classe ExcecaoC
			ExcecaoC.lancarExcecao();
		} catch (ExcecaoA ex) { // Aqui nos capturamos a Excecao.
			System.out.println(ex.getMessage()); // Imprimimos a mensagem dela.
		}
	}

Mas como nos capturamos a ExcecaoA e lançamos a ExcecaoC o código acima nos ira funcionar não é ? Não, o código acima ira funcionar graças ao polimorfismo que ira tratar a ExcecaoC como se fosse a ExcecaoA.

Agradeço a resposta de todos mas a minha dúvida foi de fevereiro do ano passado, já foi resolvida faz tempo. Obrigado.

Então meu caro lucas_guj, a minha surgiu e através desse seu exercício que me ajudou foi que fiz “algo”, enfim, o código que você postou é o correto?
Agradeço se puder confirmar!

Então meu caro lucas_guj, a minha surgiu e através desse seu exercício que me ajudou foi que fiz “algo”, enfim, o código que você postou é o correto?
Agradeço se puder confirmar!

Não o meu código não está correto, como você pode ver no enunciado, ele pede para fazer um bloco catch para capturar uma exceção do tipo A que quando ocorrem exceções do tipo B e C ele vai capturar também.

Então meu caro lucas_guj, a minha surgiu e através desse seu exercício que me ajudou foi que fiz “algo”, enfim, o código que você postou é o correto?
Agradeço se puder confirmar!

Não o meu código não está correto, como você pode ver no enunciado, ele pede para fazer um bloco catch para capturar uma exceção do tipo A que quando ocorrem exceções do tipo B e C ele vai capturar também.

Obrigado lucas_guj um dia eu aprendo exceções, rsrs, valeu!

Então meu caro lucas_guj, a minha surgiu e através desse seu exercício que me ajudou foi que fiz “algo”, enfim, o código que você postou é o correto?
Agradeço se puder confirmar!

Não o meu código não está correto, como você pode ver no enunciado, ele pede para fazer um bloco catch para capturar uma exceção do tipo A que quando ocorrem exceções do tipo B e C ele vai capturar também.

Obrigado lucas_guj um dia eu aprendo exceções, rsrs, valeu!

De nada, tranquilo.

Bom dia, será que vc poderia postar aqui o seu código resolvido?