Floating point literals provide values that can be used where you need a float or double instance. There are three kinds of floating point literal.
(The JLS syntax rules combine the two decimal forms into a single form. We treat them separately for ease of explanation.)
There are distinct literal types for float and double literals, expressed using suffixes. The various forms use letters to express different things. These letters are case insensitive.
The simplest form of floating point literal consists of one or more decimal digits and a decimal point (.) and an optional suffix (f, F, d or D). The optional suffix allows you to specify that the literal is a float (f or F) or double (d or D) value. The default (when no suffix is specified) is double.
For example
0.0 // this denotes zero
.0 // this also denotes zero
0. // this also denotes zero
3.14159 // this denotes Pi, accurate to (approximately!) 5 decimal places.
1.0F // a `float` literal
1.0D // a `double` literal. (`double` is the default if no suffix is given)
In fact, decimal digits followed by a suffix is also a floating point literal.
1F // means the same thing as 1.0F
The meaning of a decimal literal is the IEEE floating point number that is closest to the infinite precision mathematical Real number denoted by the decimal floating point form. This conceptual value is converted to IEEE binary floating point representation using round to nearest. (The precise semantics of decimal conversion are specified in the javadocs for [Double.valueOf(String)](<http://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String->) and [Float.valueOf(String)](<http://docs.oracle.com/javase/8/docs/api/java/lang/Float.html#valueOf-java.lang.String->), bearing in mind that there are differences in the number syntaxes.)
Scaled decimal forms consist of simple decimal with an exponent part introduced by an E or e, and followed by a signed integer. The exponent part is a short hand for multiplying the decimal form by a power of ten, as shown in the examples below. There is also an optional suffix to distinguish float and double literals. Here are some examples:
1.0E1 // this means 1.0 x 10^1 ... or 10.0 (double)
1E-1D // this means 1.0 x 10^(-1) ... or 0.1 (double)
1.0e10f // this means 1.0 x 10^(10) ... or 10000000000.0 (float)
The size of a literal is limited by the representation (float or double). It is a compilation error if the scale factor results in a value that is too large or too small.
Starting with Java 6, it is possible to express floating point literals in hexadecimal. The hexadecimal form have an analogous syntax to the simple and scaled decimal forms with the following differences:
0) and then an x or X.