Como lançar um erro que não está na assinatura do método?

amigo desculpa ai, mas estamos mais avançados do que macaco. Mesmo sendo herdeiros deles rsrsrs

passar todas as exceptions no metodo não resolve

public void meuMetodo() throws IOException, SQLException, ..., ..., ..., blablabal

Então, nao posso fazer isto pq estou implementando uma interface e ela possui um método onde sua assinatura não possui as exceçoes do reflection.

A interface não fui eu que fiz, é do Spring e ele espera que quem use implemente ela, só que resolvi dentro dele usar reflection e agora não posso jogar as exceçoes para quem chamou o método.

uh

então talvez isso te ajude

try
{
}
catch ( Exception e )
{
    throw new SuaException(e);
}

Amigo, qualquer exception que seja filha de RuntimeException não será checada na compilação.
Creio que resolva seu caso:

if(erro) throw new RuntimeException("Erro");

bruxel:

uh

então talvez isso te ajude

try
{
}
catch ( Exception e )
{
    throw new SuaException(e);
}

Tb não é possível, nem compila.

lokidarkeden:

Amigo, qualquer exception que seja filha de RuntimeException não será checada na compilação.
Creio que resolva seu caso:

if(erro) throw new RuntimeException("Erro");

Só que neste caso quem chama o método tera que ter try catch para RuntimeException o que não é obrigatório. Não seria o ideal pois quem usar minhas classes poderá não por esse try catch.

Teria não, pois como te falei RuntimeException não é checada na compilação.
Ela é uma exceção unchecked. O programa vai rodar, e dar pau, só isso.
Runtime.

lokidarkeden:

Teria não, pois como te falei RuntimeException não é checada na compilação.
Ela é uma exceção unchecked. O programa vai rodar, e dar pau, só isso.
Runtime.

Então, mas eu queria obrigar a usar o try catch para o desenvolvedor tratar o erro corretamente. O que dá p/ eu fazer é informar no javadoc que as execoes do reflection estão como runtimeexception.

descupe faltou uma parte

public void seuMetodo()
{
    try
    {
    }
    
    catch ( SuaException se )
    {
        try
        {
             throw new Exception( se );
        }
        
        catch( Exception e )
        {
            e.printStackTrace();
        }
    }
}

fausto, faça o seguinte... pegue a exceção original, aquela definida na interface.... vamos supor que a interface esta escrita assim

public void metodo() throws InterfaceException;

veja que isso é uma suposição, troque toda ocorrencia daqui para frente de InterfaceException, para o nome da exeção que existe na sua interface.... e troque a asisnatua metodo() pelo método que vc esta implementando...

na sua implementação... vc fala

public void metodo() throws InterfaceException {

   try {
        //... faça todas as suas operações normalmente
   } catch (Exception e) {
        //... Aqui vc vai segurar as exceções que ocorrerem dentro do q vc fizer, na variável "e"

        /**
         * ... então vc vai criar 1 nova exceção, do mesmo tipo da assinatura da interface, 
         * e vai amarrar a exceção real, que ocorreu aqui, na exceção que vc esta criando.
         * 
         * vc pode recuperar essa exceção mais tarde pelo comando getCause(), de exceções, 
         * neste caso aqui, vc esta afirmando que houve uma exceção do mesmo tipo do que esta
         * na assinatura da interface, porem que esta exceção se deu, causada por um outra exceção
         * que vai amarrada em "cause".
         *
         * veja que toda exceção descente teu seu construtor Exception(String message, Throwable cause)
         */
        throw new InterfaceException("Houve uma exceção, não previsa, veja a causa em getCause",e);       
   }

}

alguem mais pra cima ja tinha dado essa solução, mais vc não tinha compreendido direito que o suaexception que ele falava era a exceção da assinatura do seu método

abraços

Lavieri era bem isso que eu estava procurando. Realmente não vi/entendi isto nas respostas anteriores.

Só que infelizmente a exceção do método da interface é a javax.naming.NamingException que não possui este construtor

O que estou tentando fazer é extender o NamingException e adicionar o construtor. E, claro, usar ele na assinatura do método. Vamos ver até onde vou.

fausto:

Lavieri era bem isso que eu estava procurando. Realmente não vi/entendi isto nas respostas anteriores.

Só que infelizmente a exceção do método da interface é a javax.naming.NamingException que não possui este construtor :(

O que estou tentando fazer é extender o NamingException e adicionar o construtor. E, claro, usar ele na assinatura do método. Vamos ver até onde vou.

é ... mais note que.... setRootCause(Throwable e)
Records the root cause of this NamingException.

portanto....

só fazer

public void metodo() throws NamingException {

   try {
        //... faça todas as suas operações normalmente
   } catch (Exception e) {
        //... Aqui vc vai segurar as exceções que ocorrerem dentro do q vc fizer, na variável "e"

        /**
         * ... então vc vai criar 1 nova exceção, do mesmo tipo da assinatura da interface, 
         * e vai amarrar a exceção real, que ocorreu aqui, na exceção que vc esta criando.
         * 
         * vc pode recuperar essa exceção mais tarde pelo comando getCause(), de exceções, 
         * neste caso aqui, vc esta afirmando que houve uma exceção do mesmo tipo do que esta
         * na assinatura da interface, porem que esta exceção se deu, causada por um outra exceção
         * que vai amarrada em "cause".
         *
         * veja que toda exceção descente teu seu construtor Exception(String message, Throwable cause)
         */
        NamingException e2 = new NamingException ("Houve uma exceção, não previsa, veja a causa em getRootCause");
        e2.setRootCause(e);
        throw e2;
   }

}

use

getRootCause()
Retrieves the root cause of this NamingException, if any.

para recuperar a causa

Ps.: editei o código, tava com alguns erros ^^… mais o conceito ta ai, agora é so aplicar

Valeu Lavieri, ficou excelente. 8)