Dúvida sobre try/catch

Não sei se é a melhor maneira, mas você pode chamar a classe de novo com runtime:

import java.io.*; import javax.swing.*; public class Divisao { public static void main(String args[]) { try{ //double n1 = Double.parseDouble(JOptionPane.showInputDialog("Digite um número")); //double n2 = Double.parseDouble(JOptionPane.showInputDialog("Digite outro número")); //double res = n1 / n2; int n1 = Integer.parseInt(JOptionPane.showInputDialog("Digite um número")); int n2 = Integer.parseInt(JOptionPane.showInputDialog("Digite outro número")); int res = n1 / n2; JOptionPane.showMessageDialog(null,String.valueOf(res),"Resultado",1); } catch(NumberFormatException e ){ JOptionPane.showMessageDialog(null,"Digite somente números.","Caracteres inválidos",1); try{ Runtime.getRuntime().exec("java Divisao"); } catch(IOException eIO) { // nao abriu o arquivo } } catch(ArithmeticException e ){ JOptionPane.showMessageDialog(null,"Divisão por zero.","Erro na divisão",1); } System.exit(0); } }
Observe que eu mudei algumas coisas no seu código original (além do runtime e o tratamento da exceção de IO).
O valueOf(res) no lugar de res no JOptionPane (aquela posição tem que ser String) e o System.exit(0); para fechar a aplicação no final.

“JavaDrops”:

Não sei se é a melhor maneira, mas você pode chamar a classe de novo com runtime:

import java.io.*; import javax.swing.*; public class Divisao { public static void main(String args[]) { try{ //double n1 = Double.parseDouble(JOptionPane.showInputDialog("Digite um número")); //double n2 = Double.parseDouble(JOptionPane.showInputDialog("Digite outro número")); //double res = n1 / n2; int n1 = Integer.parseInt(JOptionPane.showInputDialog("Digite um número")); int n2 = Integer.parseInt(JOptionPane.showInputDialog("Digite outro número")); int res = n1 / n2; JOptionPane.showMessageDialog(null,String.valueOf(res),"Resultado",1); } catch(NumberFormatException e ){ JOptionPane.showMessageDialog(null,"Digite somente números.","Caracteres inválidos",1); try{ Runtime.getRuntime().exec("java Divisao"); } catch(IOException eIO) { // nao abriu o arquivo } } catch(ArithmeticException e ){ JOptionPane.showMessageDialog(null,"Divisão por zero.","Erro na divisão",1); } System.exit(0); } }
Observe que eu mudei algumas coisas no seu código original (além do runtime e o tratamento da exceção de IO).
O valueOf(res) no lugar de res no JOptionPane (aquela posição tem que ser String) e o System.exit(0); para fechar a aplicação no final.

Valeu cara, era isso mesmo que eu queria. Veja se vc me ajuda em mais uma duvidazinha. Como está na minha classe, eu estou dizendo que n1 e n2 é do tipo int certo!!!.. blz… com esse tipo, o erro de “divisão por zero” funciona normalmente. Agora se eu disser que n1 e n2 é do tipo double, o resultqado da “infinity” e o erro de divisão por zero não aparece.

Vc saber pq??

Olá…

É só você fazer algo assim:

import javax.swing.*; 


public class Divisao{ 

	public static void main(String args[]){ 
		int n1 = 0;
		int n2 = 0;
		boolean ok = false;
		boolean diviZero = true;

		while (diviZero) {
			while (!ok) {
				try{ 
					n1 = Integer.parseInt(JOptionPane.showInputDialog("Digite um número")); 
					ok = true;
				} catch(NumberFormatException e ){ 
					JOptionPane.showMessageDialog(null,"Digite somente números.","Caracteres inválidos",1); 
				}
			}

			ok = false;
			while (!ok) {
				try{ 
					n2 = Integer.parseInt(JOptionPane.showInputDialog("Digite outro número")); 
					ok = true;
				} catch(NumberFormatException e ){ 
					JOptionPane.showMessageDialog(null,"Digite somente números.","Caracteres inválidos",1); 
				}
			}

			try{ 
				int res = n1 / n2; 
				diviZero = false;
				JOptionPane.showMessageDialog(null,res,"Resultado",1); 
			} catch(ArithmeticException e ){ 
				JOptionPane.showMessageDialog(null,"Divisão por zero.","Erro na divisão",1); 
			} 

			ok = false;
		}
	} 
}

Espero ter ajudado…
Abraços…

jonlordbr,

Acho que você colocou os ok = false no lugar errado. Não tinha que ser dentro dos catch?

Prego, vou te dar uma justificativa que “pode” estar errada.

Quando você divide por zero o que acontece?
Por exemplo, x = 5/0
Qual o resultado disso?

Não existe, certo?

Mas e quando você faz isso: x = 5.0/0.0 ???

Na verdade você não está usando o zero absoluto e sim uma aproximação do zero. (usando limites) lim 5/y, com y tendendo a zero = infinito.

Se eu estiver errado me corrijam.

Olá…

“JavaDrops”:

jonlordbr,

Acho que você colocou os ok = false no lugar errado. Não tinha que ser dentro dos catch?

Não estão no lugares errados não:

// Aqui inicia o ok (false porque é pra ficar no while enquanto for falso)
         ok = false; 
         while (!ok) { 
            try{ 
               n2 = Integer.parseInt(JOptionPane.showInputDialog("Digite outro número")); 
               ok = true; // Se chegar neste ponto a entrada está correta
            } catch(NumberFormatException e ){ 
               JOptionPane.showMessageDialog(null,"Digite somente números.","Caracteres inválidos",1); 
               // Caso chegue aqui, o ok == false e então o while vai ser repetido
            } 
         }

Espero que você tenha entendido o que eu fiz…
Abraços…

Foi mal, marquei toca.

Por exemplo:

try{ n1 = Integer.parseInt(JOptionPane.showInputDialog("Digite um número")); ok = true; } catch(NumberFormatException e ){ JOptionPane.showMessageDialog(null,"Digite somente números.","Caracteres inválidos",1); }Não tinha me ligado que o ok = true só acontece se não der erro na linha anterior.
Isso é pra eu aprender a não falar sem verificar antes

Ai JavaDrops qto a parte matematica da sua explicação:

blz, matematicamente me parece correto, mas qdo se usa variavel double o java usa esses tipos de padrões matematicos???
pq para se chegar nessa conclusao usa-se graficos e talz…
isso é valido para alguma outra conclusao matematica baseada em graficos tmb?
exemplo usando os limites:
X/0 = infinito
X/infinito = 0

Fierodd,

Não entendi muito bem o que você quis dizer mas, como eu coloquei, é uma “justificativa” que “pode” estar errada.

O Java faz coisas desse tipo:
0.56 + 0.13 = 0.6900000000000001

O que me fez pensar que ele não deve considerar o 0.0 como zero (só existe a exceção para o tipo inteiro) e sim como uma aproximação do mesmo. Pelo menos foi a única explicação lógica que me ocorreu (ainda mais que o resultado da divisão por esse 0.0 dá infinito).

Mas não sei dizer se isso é o que acontece com certeza.

“JavaDrops”:

O Java faz coisas desse tipo:
0.56 + 0.13 = 0.6900000000000001

Não é o Java que faz coisa desse tipo, é a própria notação em binário.
0.05 é uma dízima, por exemplo.[/quote]

O que eu quis dizer é que o Java não trata esse tipo de “erro”. Se você está somando dois números com duas casas decimais esperasse que o resultado tenha no máximo duas casas decimais e não dezesseis…