Understanding Classes and Static Member Functions

A common starting belief is that every function in the Math class behaves like an ordinary rounding or measurement tool. Under that belief, you might expect angles to be supplied in degrees, floor to return an int, and random to produce truly random values. The Math class does not work that way. Its static member functions each have specific input conventions and return-value rules, and learning those rules is more useful than memorizing function names in isolation.

In this article you will trace how several Math calls transform their inputs. Before reading each explanation, try to predict the result. The mismatch between your prediction and the actual rule is where most of the learning happens.

The functions in the Math class are static member functions. A static member function belongs to the class itself, so you call it by writing the class name, a dot, and the function name, such as Math.abs(x). You do not need to create a Math object first. The class name is the thing you write in front of the dot, and no object is involved in the call.

The Math class groups several families of functions. Math.pow(x, y) computes x raised to the power y. Math.exp(x) computes the number e raised to the power x. Math.log(x) computes the logarithm of x with base e, which is called the natural logarithm. These three are related but distinct operations, so it helps to read each function's name against its definition rather than assuming they are interchangeable.

Math.abs(x) computes the absolute value of x. It is an exception to a general pattern. Most Math functions return a double regardless of the numeric type of the parameter, but Math.abs(x) returns a value with the same type as its input. Math.abs(9) returns 9, and an int input produces an int result.

Trigonometric functions use radians, and inverse trigonometric functions return radians. This is the most common source of surprise with the Math class. If you pass 90 to Math.sin, the computer treats 90 as 90 radians, not 90 degrees. Because a full turn is about 6.283 radians, 90 radians is many turns around the circle, and the sine of that angle is about 0.894, not 1.

A right angle is 90 degrees, and it corresponds to pi divided by 2 radians. To get the sine of a 90-degree angle, convert the angle to radians first by multiplying degrees by pi and dividing by 180. Passing Math.PI / 2 to Math.sin gives 1.0, which matches the sine of 90 degrees.

Floor, round, and ceil use different rounding rules, and each one returns a double. Math.floor(x) moves a value down to the nearest whole number that is not greater than x. Math.ceil(x) moves a value up to the nearest whole number that is not less than x. Math.round(x) moves a value to the nearest whole number, and it has a specific tie-breaking rule for values exactly halfway between two integers.

Negative values are where the three functions are easiest to confuse. For -2.5, floor moves downward to -3.0, because -3 is the largest whole number that is not greater than -2.5 is wrong to say; the correct reading is that floor always moves toward negative infinity, so -2.5 goes down to -3.0. Ceil moves toward positive infinity, so -2.5 goes up to -2.0. Round, for a halfway value like -2.5, rounds toward positive infinity in Java, so it goes to -2 rather than -3.

Math.random() returns a randomly chosen double in the range from 0.0, inclusive, to 1.0, exclusive. Inclusive means 0.0 is a possible result. Exclusive means 1.0 is never returned. Every value the function produces therefore satisfies 0.0 <= result < 1.0.

The values are pseudorandom. The computer calculates them with a procedure rather than producing truly random values. The source describes them as effectively random enough for most purposes it covers, but a learner should remember that they are computed, not drawn from a physical source of randomness.

A common way to use this range is to scale the result. Multiplying Math.random() by 6 gives a value from 0.0 up to, but not including, 6.0. Taking the floor of that value and adding 1 produces a whole number from 1 through 6. This pattern follows directly from the range rule and the floor behavior described above.