Floating-point

Floating-point numbers, are number that can represent fractions as well as integers. In Java, the floating-point type is called double, which is short for “double-precision."

You can create floating-point variables and assign values to them using the same syntax we used for the other types. For example:

  double pi;
  pi = 3.14159;

It is also legal to declare a variable and assign a value to it at the same time:

  int x = 1;
  String empty = "";
  double pi = 3.14159;

This syntax is common; a combined declaration and assignment is sometimes called an initialization.

Although floating-point numbers are useful, they are a source of confusion because there seems to be an overlap between integers and floating-point numbers. For example, if you have the value 1, is that an integer, a floating- point number, or both?

Java distinguishes the integer value 1 from the floating-point value 1.0, even though they seem to be the same number. They belong to different types, and strictly speaking, you are not allowed to make assignments between types.
For example, the following is illegal:

  int x = 1.1;

because the variable on the left is an int and the value on the right is a double. But it is easy to forget this rule, especially because there are places where Java will automatically convert from one type to another. For example:

  double y = 1;

should technically not be legal, but Java allows it by converting the int to a double automatically. This leniency is convenient, but it can cause problems; for example:

  double y = 1 / 3;

You might expect the variable y to get the value 0.333333, which is a legal floating-point value, but in fact it gets 0.0. The reason is that the expression on the right is the ratio of two integers, so Java does integer division, which yields the integer value 0. Converted to floating-point, the result is 0.0.

One way to solve this problem (once you figure out what it is) is to make the right-hand side a floating-point expression:

  double y = 1.0 / 3.0;

This sets y to 0.333333, as expected.

The operations we have seen so far-addition, subtraction, multiplication, and division-also work on floating-point values, although you might be interested to know that the underlying mechanism is completely different. In fact, most processors have special hardware just for performing floating-point operations.