# double

double represents double-precision numbers. double is 64-bit width and its range is from 4.9e-324 to 1.8e+308 approximately.

Here is a program that uses double variables to compute the area of a circle:

``````
public class Main {
public static void main(String args[]) {
double pi, r, a;

r = 10.8888; // radius of circle
pi = 3.1415926; // pi, approximately
a = pi * r * r;

System.out.println("Area of circle is " + a);
}
}

``````

The output:

``````
Area of circle is 372.4859596381597
``````

## double type Literals

double type numbers have decimal values with a fractional component.

They can be expressed in either standard or scientific notation. Standard notation consists of a whole number component followed by a decimal point followed by a fractional component.

For example, 2.0, 3.14159, and 0.6667.

``````
public class Main {
public static void main(String args[]) {
double d =  3.14159;
System.out.print(d);//3.14159
}
}
``````

Scientific notation uses a standard-notation, floating-point number plus a suffix that specifies a power of 10 by which the number is to be multiplied.

The exponent is indicated by an E or e followed by a decimal number, which can be positive or negative.

For example, 6.02E23, 314159E-05, and 4e+100.

``````
public class Main {
public static void main(String[] argv) {
double d1 = 6.022E23;
double d2 = 314159E-05;
double d3 = 2e+100;

System.out.println("d1 is " + d1);
System.out.println("d2 is " + d2);
System.out.println("d3 is " + d3);
}

}
``````

The output generated by this program is shown here:

``````
d1 is 6.022E23
d2 is 3.14159
d3 is 2.0E100
``````

You can explicitly specify a double literal by appending a D or d.

``````
public class Main {
public static void main(String args[]) {
double d =  3.14159D;
System.out.print(d);//3.14159
}
}
``````

Java's floating-point calculations are capable of returning +infinity, -infinity, +0.0, -0.0, and NaN

dividing a positive number by 0.0 returns +infinity. For example, System.out.println(1.0/0.0); outputs Infinity.

``````
public class Main{
public static void main(String[] args) {
System.out.println(1.0/0.0);
}

}
``````

## Infinity

Dividing a negative number by 0.0 outputs -infinity. For example, System.out.println(-1.0/0.0); outputs -Infinity.

``````
public class Main{
public static void main(String[] args) {
System.out.println(-1.0/0.0);
}

}
``````

Output:

``````
-Infinity
``````

Dividing 0.0 by 0.0 returns NaN. square root of a negative number is NaN

For example, System.out.println(0.0/0.0) and System.out.println(Math.sqrt(-1.0)) output NaN.

Dividing a positive number by +infinity outputs +0.0. For example, System.out.println(1.0/(1.0/0.0)); outputs +0.0.

Dividing a negative number by +infinity outputs -0.0. For example, System.out.println(-1.0/(1.0/0.0)); outputs -0.0.

``````
public class Main {
public static void main(String[] args) {
Double d1 = new Double(+0.0);
System.out.println(d1.doubleValue());

Double d2 = new Double(-0.0);
System.out.println(d2.doubleValue());
System.out.println(d1.equals(d2));
System.out.println(+0.0 == -0.0);

}
}
``````

The following code parses command-line arguments into double precision floating-point values

``````
public class Main {
public static void main(String[] args) {
if (args.length != 3) {
System.err.println("usage: java Main value1 op value2");
System.err.println("op is one of +, -, *, or /");
return;
}
try {
double value1 = Double.parseDouble(args[0]);
double value2 = Double.parseDouble(args[2]);
if (args[1].equals("+")) {
System.out.println(value1 + value2);
} else if (args[1].equals("-")) {
System.out.println(value1 - value2);
} else if (args[1].equals("*")) {
System.out.println(value1 * value2);
} else if (args[1].equals("/")) {
System.out.println(value1 / value2);
} else {
System.err.println("invalid operator: " + args[1]);
}
} catch (Exception nfe) {
System.err.println("Bad number format: " + nfe.getMessage());
}
}
}
``````
Home
Java Book
Language Basics

Primitive Types: