Java ArithmétiqueException

L'exception arithmétique Java est une sorte d'erreur non vérifiée ou de résultat inhabituel de code qui est générée lorsqu'une mauvaise opération arithmétique ou mathématique se produit dans le code au moment de l'exécution. Un problème d'exécution, également appelé exception, se produit lorsque le dénominateur est un entier 0, que la JVM est incapable d'évaluer le résultat et que, par conséquent, l'exécution du programme est terminée et qu'une exception est levée. Le point auquel l'exception a été déclenchée, le programme se termine mais le code antérieur est exécuté et le résultat est affiché.

La classe de base de l'exception arithmétique Java est lang.ArithmeticException, qui relève de java.lang.RuntimeException.

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Structure d'ArithmeticException en Java

Structure de la classe de base ArithmeticException :

Constructeur d'ArithmeticException

1. ArithmeticException() : Définissez une exception arithmétique sans paramètre passé ou sans message détaillé.

2. ArithmeticException(String s): Définissez une ArithmeticException avec un paramètre passé.

s :s est le message détaillé 

Comment fonctionne ArithmeticException en Java ?

Vous trouverez ci-dessous les deux situations pouvant conduire à Java ArithmeticException :

• Division d'un nombre par Zéro qui n'est pas défini et un entier.
• Nombres décimaux longs sans fin parBig Decimal.

1. Division d'un nombre par un zéro entier

Une exception arithmétique en Java est levée lorsque nous essayons de diviser un nombre par zéro. Ci-dessous le code java pour illustrer l'opération :

Exemple n°1

Code :

package com.java.exception;
public class ArithmeticException
{
void division(int a,int b)
{
int c=a/b;
System.out.println("Division has been successfully done");
System.out.println("Value after division: "+c);
}
public static void main(String[] args)
{
ArithmeticException ex=new ArithmeticException();
ex.division(10,0);
}
}

Sortie :

• lang.ArithmeticException : Exception levée par le langage Java lors de la division
• / par zéro : C'est le message détaillé donné à la classe ArithmeticException lors de la génération de l'instance ArithmeticException.

Comme nous avons divisé 10 par 0, où 0 est un entier et n'est pas défini, cela lève une exception arithmétique supérieure.

Exemple n°2

Code :

//package com.java.exception;
public class ArithmeticException
{
void division(int a,int b)
{
int c=a/b;
System.out.println("Division of a number is successful");
System.out.println("Output of division: "+c);
}
public static void main(String[] args)
{
ArithmeticException ex=new ArithmeticException();
ex.division(10,5);
}
}

Sortie :

2. Nombres décimaux longs sans fin par grande décimale

Java possède une classe BigDecimal qui représente des nombres décimaux jusqu'à un grand nombre de chiffres de précision. Cette classe de Java possède également un ensemble de fonctionnalités qui ne sont pas disponibles dans les types de données primitifs, par exemple entier, double et flottant. Ces fonctionnalités permettent d'arrondir les nombres décimaux

Ci-dessous le code à titre d'illustration :

Exemple n°1

Code :

//package com.java.exception;
import java.math.BigDecimal;
public class ArithmeticException
{
public static void main(String[] args)
{
BigDecimal a=new BigDecimal(1);
BigDecimal b=new BigDecimal(6);
a=a.divide(b);
System.out.println(a.toString());
}
}

Sortie :

Dans le code Java écrit ci-dessus, comme la grande classe décimale ne sait pas quoi faire avec la sortie de division, elle lève ou affiche donc une exception arithmétique dans la console de sortie.

Il génère une exception avec un message détaillé « Expansion décimale sans fin, pas de représentation exacte. »

Une solution possible pour la grande classe décimale ci-dessus est d'indiquer le nombre de décimales dont nous avons besoin à partir d'un grand nombre décimal, puis de limiter la valeur à un nombre défini de décimales. Par exemple, c doit être limité à 7 décimales en arrondissant le nombre à la 7^ième valeur de précision décimale.

Exemple n°2

Code :

//package co.java.exception;
import java.math.BigDecimal;
public class ArithmeticException
{
public static void main(String[] args)
{
BigDecimal a=new BigDecimal(1);
BigDecimal b=new BigDecimal(6);
a=a.divide(b,7,BigDecimal.ROUND_DOWN);// limit of decimal place
System.out.println(a.toString());
}
}

Sortie :

La console de sortie affiche le résultat sous la forme d'un nombre avec une 7^ième valeur de point décimal, ce qui signifie que l'arrondi fonctionne correctement.

Comment éviter ou gérer l'exception arithmétique Java ?

La gestion de l'exception levée par la machine virtuelle Java est appelée gestion des exceptions. L'avantage de la gestion des exceptions est que l'exécution du code n'est pas arrêtée.

Une exception est gérée en utilisant une combinaison de try et catch. Un bloc try/catch est placé dans le code qui pourrait générer une exception. Le code écrit à l’intérieur d’un bloc try/catch est appelé code protégé.

Syntaxe :

try
{
set of statements//protected code
}
catch (exceptionname except)
{
// Catch set of statements---can contain single catch or multiple.
}

ArithmeticException Handling using try & Catch Blocks

• Write the statements that can throw ArithmeticException with try and catch blocks.
• When an exception occurs, the execution falls to the catch block from an exception’s point of occurrence. It executes the catch block statement and continues with the statement present after the try and catch blocks. Below is the example:

Code:

public class ExceptionHandled
{
public static void main(String args[])
{
int x =100, y = 0;
int z;
System.out.println("Hello world");
try
{
z = x/y;
System.out.println(z);
}
catch(ArithmeticException except)
{
System.out.println("Avoid dividing by integer 0" + except );
}
System.out.println("Hello class");
System.out.println("Hello there");
}
}

Output:

Hello class and Hello, there are also printed on the output console apart from Hello world. This is the outcome of the exception handling mechanism.

Explanation:

1. Try, and catchblocks are exception handling keywords in Java used completely used to handle the exception or unchecked error raised in the code without halting the execution of the code.
2. Detect the trouble creating statements and place them in the try block. When the try block throws the exception, the catch block handles that exception, and the execution of the program goes further to the last statement.
3. If the try block does not throw the exception, the catch block is simply overlooked.
4. Run a suitable exception handler or statements in the catch block to handle or detect the exception thrown by the try block successfully.

Conclusion

This article has learned about java arithmetic exception and how to handle the exception under try and catch block. An arithmetic exception occurs most of the time because of the division of a number by integer 0. In this article, I have used a single catch for a single try, but we can also use multiple catch for a single try.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!