Strictfp Keyword in Java

Last Updated: 05 July, 2023

strictfp stands for strict floating-point.

In Java, strictfp is a modifier or keyword that was introduced in the JDK 1.2 version to provide exactly the same results on every JVM and platform while performing operations in the floating-point variables predicted by IEEE 754.

We use the strictfp keyword if we are doing floating-point calculations. By default, the floating-point computations in Java are platform-dependent. And so, the floating-point outcome's precision depends on the target platform's hardware and the CPU's floating-point processing (16/32/64-bit processors) capability.

📝  The strictfp keyword can be used with methods, classes, and interfaces, but it cannot be used with abstract methods, variables, or constructors.

👉 All valid implementations of the strictfp keyword

1. strictfp using with Method

class Calculator { strictfp void calculateInterestAmt() { // code } }

Lab 2 : strictfp using with Class

/* All concrete methods declared in this class are implicitly strictfp */ strictfp class Calculator { void calculateWeight() { // code } void calculateHeight() { // code } }

Lab 3 : strictfp using with Interface

/* All the methods of this interface becomes implicitly strictfp when used during inheritance */ strictfp interface Calculator { void calculateInterestAmt(); void calculateGSTAmt(); }

When a class or an interface is declared with the strictfp modifier, then all methods declared in the class or interface and all nested types declared in the class are implicitly strictfp.

👉 All invalid implementations of the strictfp keyword

1. Using strictfp with variables

class Calculator { strictfp float interestRate = 7.2f; // Invalid declaration }

2. Using strictfp with the Constructor

class Calculator { strictfp Calculator() { // Invalid declaration // code } }

3. Using strictfp with the Abstract Method

abstract class Calculator { strictfp abstract calculateInterestAmt(); // Invalid declaration }

👉 Rules of the strictfp in Java

• The strictfp modifier can only be applied to non-abstract methods, classes, and interfaces.
• It cannot be applied to constructors, abstract methods, or variables.
• If an interface or class is declared with strictfp, then all methods and nested types within that interface or class are implicitly strictfp.
• In the absence of the strictfp keyword, the precision of floating-point calculations depends on the platform's hardware, such as the CPU's floating-point capability.

It's important to note that using strictfp can impact performance since it disables some optimization techniques that the JVM might otherwise employ for floating-point calculations. Therefore, it's generally recommended to use strictfp only when strict precision is required.