The following statement throws `java.lang.ArithmeticException: / by zero`

as obvious.

```
System.out.println(0/0);
```

because the literal `0`

is considered to be an `int`

literal and divide by zero is not allowed in integer arithmetic.

The following case however **doesn't** throw any exception like `java.lang.ArithmeticException: / by zero`

.

```
int a = 0;
double b = 6.199;
System.out.println((b/a));
```

It displays `Infinity`

.

The following statement produces `NaN`

(Not a Number) with no exception.

```
System.out.println(0D/0); //or 0.0/0, or 0.0/0.0 or 0/0.0 - floating point arithmetic.
```

In this case, both of the operands are considered to be double.

Similarly, the following statements **don't** throw any exception.

```
double div1 = 0D/0; //or 0D/0D
double div2 = 0/0D; //or 0D/0D
System.out.printf("div1 = %s : div2 = %s%n", div1, div2);
System.out.printf("div1 == div2 : %b%n", div1 == div2);
System.out.printf("div1 == div1 : %b%n", div1 == div1);
System.out.printf("div2 == div2 : %b%n", div2 == div2);
System.out.printf("Double.NaN == Double.NaN : %b%n", Double.NaN == Double.NaN);
System.out.printf("Float.NaN == Float.NaN : %b%n", Float.NaN == Float.NaN);
```

They produce the following output.

```
div1 = NaN : div2 = NaN
div1 == div2 : false
div1 == div1 : false
div2 == div2 : false
Double.NaN == Double.NaN : false
Float.NaN == Float.NaN : false
```

They all return `false.`

Why is this operation (division by zero) allowed with floating point or double precision numbers?

By the way, I can understand that floating point numbers (double precision numbers) have their values that represent *positive infinity*, *negative infinity*, *not a number* (`NaN`

)...

`1/0`

throw an exception instead of returning`Infinity`

? The answer is that a two's-complement integer (which is what Java's`int`

is) doesn't have any bits available to store special values like`Infinity`

or`NaN`

, so since the result is not representable in the desired type, an exception has to be thrown. Floating-point numbers do not have this problem (there is a bit pattern available for`Infinity`

), and therefore no exception is needed.