[Resolvido] Declarando novos tipos de exceção

3 respostas
C

Boa tarde a todos,

Estou estudando Java pelo livro do Deitel e li que uma nova classe de exceção típica contém somente quatro construtores:

1) Um que não recebe nenhum argumento e passa mensagem de erro padrão String para o construtor de superclasse;

2) Um que recebe uma mensagem de erro personalizada como uma String e passa-a para o construtor de superclasse;

3) Um que recebe uma mensagem de erro personalizada como uma String e um Throwable (exceções encadeadas) e passa ambos para o construtor de superclasse;

4) Um que recebe um Throwable (exceções encadeadas) e passa-o para o construtor de superclasse;

Gostaria de pedir, por favor, se alguém poderia me esclarecer as seguintes dúvidas:

a) Por que são precisos esses quatros construtores?

b) Com que finalidade esse construtor passa dados para o construtor da superclasse?

c) Como posteriormente esses dados passados para o construtor da superclasse poderiam ser acessados?

Eu tentei também fazer o seguinte código exemplo, mas não sei se a sua lógica faz sentido.

package excecao25;
public class TratamentoNovo extends Exception
{
    int valor;
    public TratamentoNovo() 
    { 
        super(); 
    }
    public TratamentoNovo(final String msg)
    { 
        super(msg);
    }
    public TratamentoNovo(final Throwable t)
    { 
        super(t); 
    }
    public TratamentoNovo(final String msg, final Throwable t)
    { 
        super(msg,t);
    }
    public TratamentoNovo(int valor)
    {
        this.valor = valor;
    }    
    @Override
    public String toString()
    {
        return "Excecao: o denominador eh " + valor;
    }
}

package excecao25;
public class Teste
{
    public static void Metodo(int valor) throws TratamentoNovo
    {
        try
        {
            Calcula(valor);
        }
        catch(TratamentoNovo t1)
        {
            System.err.println(t1);
        }
    }
    public static void Calcula(int valor) throws TratamentoNovo
    {
        Throwable t = null;
        if (valor == 1)
            throw new TratamentoNovo();
        if (valor == 2)
            throw new TratamentoNovo("Que valor");
        if (valor == 3)
            throw new TratamentoNovo(t);
        if (valor == 4)
            throw new TratamentoNovo("Que valor",t);
        if (valor == 5)
            throw new TratamentoNovo(valor);
        
    }
}

package excecao25;
public class Excecao 
{
    public static void main(String[] args) 
    {
        try
        {
            Teste.Metodo(3);
        }
        catch(Exception e1)
        {
            System.err.println(e1);
        } 
    }
}

Se alguém puder me ajudar com as dúvidas acima e com a análise deste código, eu agradeceria muito!

3 Respostas

gmmascarin

Não é obrigatório implementar os 4 construtores, faz se quiser, ou melhor, se for necessário para sua aplicação.

A exception que está sendo criada deve herdar de exception, error ou throwble, portanto possuirá as mesmas funcionalidades. No seu caso, chamou construtores específicos da superclasse para aproveitar as implementações/funcionalidades já existentes. Vou explicar em detalhes cada construtor:

super();

Construtor sem argumentos. Esse construtor é chamado automaticamente quando não é invocado. Não faz nada demais, apenas cria uma subclasse com as funcionalidades da classe pai.

super(msg);

Melhor passar uma mensagem na exceção, não acha? Imagine quão ruim seria uma exceção sem uma mensagem para explicar melhor o que ocorreu.

super(t);

Se já existe uma exceção que poderia explicar melhor a causa da sua exceção, então se aproveite dela.

super(msg,t);

É uma mescla das explicações acima.

Provavelmente esse dados serão acessados quando sua exceção for lançada, entretanto existem métodos para recuperar o valor. Ex:

Throwble t = getCause(); String msg = getMessage();

sergiotaborda

Já responderam, mas queria adicionar o seguinte:
Os tipos de construtor não são para implementar todos. Quantos menos, melhor.

O que é importante respeitar aqui, respondendo sua segunda pergunta , é não jogar fora a exceção original. Se não , vc mata o stacktrace.
Os dados que vc passa à classe mae são para manter o stacktrace e depois poder debugar onde aconteceu o problema originalmente.

Os dados que vc passa a mais no contrutor devem refletir os dados da exceção. Por exemplo, se vc está abrido um File e ele não existe é legal colocar o File na exceção, para depois vc poder tratar isso em outro lugar.

Vc passa o file no construtor, e depois acessa o file com um get normal. Apenas não ha set. Tudo é setado no contrutor.

Mais sobre exceções e boas práticas relacionadas.

C

Agradeço imenso ao gmmascarin e ao sergiotaborda pela gentileza de ambos em terem respondido às minhas dúvidas!!!

Isso me ajudou bastante!!!

Mais uma vez, os meus agradecimentos!!!

Criado 6 de março de 2013
Ultima resposta 6 de mar. de 2013
Respostas 3
Participantes 3