Deling door nul in Java: uitzondering, oneindigheid of geen getal

1. Overzicht

Delen door nul is een bewerking die geen betekenis heeft in de gewone rekenkunde en daarom ongedefinieerd is. Bij het programmeren echter, terwijl het wordt vaak geassocieerd met een fout, dit is niet altijd het geval.

In dit artikel gaan we verder wat gebeurt er als een deling door nul plaatsvindt in een Java-programma.

Volgens de Java-specificatie van de deelbewerking kunnen we twee verschillende gevallen van delen door nul identificeren: gehele getallen en getallen met drijvende komma.

2. Gehele getallen

Ten eerste zijn de dingen voor gehele getallen vrij eenvoudig. Het delen van een geheel getal door nul resulteert in een ArithmeticException:

assertThrows (ArithmeticException.class, () -> {int result = 12/0;});
assertThrows (ArithmeticException.class, () -> {int result = 0/0;});

3. Drijvende komma-typen

Bij het omgaan met met getallen met drijvende komma, er wordt geen uitzondering gemaakt:

assertDoesNotThrow (() -> {float resultaat = 12f / 0;});

Om dergelijke gevallen te behandelen, gebruikt Java enkele speciale numerieke waarden die de resultaten van een dergelijke bewerking kunnen vertegenwoordigen: NaN, POSITIVE_INFINITY, en NEGATIVE_INFINITY.

3.1. NaN

Laten we beginnen drijvende-kommawaarden van nul delen door nul:

assertEquals (Float.NaN, 0f / 0); assertEquals (Double.NaN, 0d / 0);

Het resultaat in deze gevallen is NaN (geen nummer).

3.2. Oneindigheid

Laten we het volgende doen deel enkele niet-nulwaarden door nul:

assertEquals (Float.POSITIVE_INFINITY, 12f / 0); assertEquals (Double.POSITIVE_INFINITY, 12d / 0); assertEquals (Float.NEGATIVE_INFINITY, -12f / 0); assertEquals (Double.NEGATIVE_INFINITY, -12d / 0);

Zoals we kunnen zien, is het resultaat ONEINDIGHEID, met het teken afhankelijk van het teken van de operanden.

Bovendien kunnen we ook het concept van negatieve nul gebruiken om bij te komen NEGATIVE_INFINITY:

assertEquals (Float.NEGATIVE_INFINITY, 12f / -0f); assertEquals (Double.NEGATIVE_INFINITY, 12f / -0f);

3.3. Geheugenvertegenwoordiging

Dus, waarom genereert deling door gehele getallen door nul een uitzondering, terwijl deling met drijvende komma door nul dat niet doet?

Laten we dit bekijken vanuit het perspectief van een geheugenweergave. Voor gehele getallen is er geen bitpatroon dat kan worden gebruikt om het resultaat op te slaan van een dergelijke operatie, terwijl getallen met drijvende komma hebben waarden zoals NaN of ONEINDIGHEID om in dergelijke gevallen te worden gebruikt.

Laten we nu de binaire weergave van een float beschouwen als S EEEEEEE E FFFFFFF FFFFFFFF FFFFFFFF met één bit (S) voor het teken, 8 bits (E) voor de exponent en de rest (F) voor de mantisse.

In elk van de drie waarden NaN, POSITIVE_INFINITY, en NEGATIVE_INFINITY, alle bits in het exponentgedeelte worden op 1 gezet.

ONEINDIGHEID heeft de mantisse-bits allemaal ingesteld op 0, terwijl NaN heeft een mantisse die niet nul is:

assertEquals (Float.POSITIVE_INFINITY, Float.intBitsToFloat (0b01111111100000000000000000000000)); assertEquals (Float.NEGATIVE_INFINITY, Float.intBitsToFloat (0b11111111100000000000000000000000)); assertEquals (Float.NaN, Float.intBitsToFloat (0b11111111100000010000000000000000)); assertEquals (Float.NaN, Float.intBitsToFloat (0b11111111100000011000000000100000));

4. Samenvatting

Kortom, in dit artikel hebben we gezien hoe deling door nul werkt in Java.

Waarden zoals ONEINDIGHEID en NaN zijn beschikbaar voor getallen met drijvende komma, maar niet voor gehele getallen. Als gevolg hiervan zal het delen van een geheel getal door nul resulteren in een uitzondering. Voor een vlotter of dubbele, Java staat de bewerking toe.

De volledige code is beschikbaar op GitHub.