Java Strictfp Keyword

by FC Team · Published April 16, 2024 · Updated April 29, 2024

This article will explore an intriguing keyword in the Java programming language called “strictfp”. We will look at what “strictfp” is all about as we go through topics like its necessity, usage, benefits, and when to use it.

In the end, we will look at a couple of example programs that use the “strictfp” keyword to grasp the concept more quickly and master it sooner. I recommend you practice each code in the article, try to make some modifications, and tinker with the code to cover different scenarios.

What is the strictfp keyword in Java?

The strictfp is a keyword introduced in Java version 1.2 that essentially works as a modifier. Strictfp is the abbreviation for strict floating point. This keyword is used to limit floating-point calculations to ensure the same result on every platform when performing operations on a floating-point variable.

In Java, floating-point computations by default are platform-dependent, hence, the floating-point outcome’s precision depends on the hardware in use.

To resolve this issue, the keyword “strictfp” was introduced in Java Development Kit 1.2 to comply with IEEE 745 rules for floating-point calculations. Now, we get the same result on every platform and have better control over the floating-point arithmetic.

How to use the strictfp keyword in Java?

As discussed above, strictfp can be used as a non-access modifier, but only with classes, non-abstract methods, and interfaces. This means that this keyword cannot be used on variables, constructors, or abstract methods.

The strictfp keyword cannot be used with any interface method. Why? Because the methods declared in interfaces are implicitly abstract. Moreover, when a class or interface is declared with the strictfp modifier, all the methods declared in the class or interface, as well as all nested types stated in the class, are implicitly strictfp.

When do we use the strictfp keyword?

Strictfp is favored whenever we care a great deal about the deterministic behavior of all floating-point computations. If we forget to use this keyword, the JVM is allowed to use any additional precision available on the target platform’s hardware.

What is the syntax of the strictfp keyword?

Before we take a look at some examples that make use of the strictfp keyword, let us take a look at the syntaxes of it:

1. Correct ways to use the strictfp keyword:

a. Applied in class:

strictfp class C{}

b. applied on an interface :

strictfp interface I{}

c. applied on method :

class C
{  
strictfp void m(){}
}

2. Wrong ways to use the strictfp keyword:

a. Can’t use strictfp with abstract classes

class B{strictfp abstract void m();}

b. Can’t use strictfp with integer datatype:

class B{strictfp int data=10;}

Examples of the strictfp keyword

1. Using the strictfp with a method declared in a class

class FirstCode 
{
    public strictfp double sum()
    {
        double num1 = 10e+10;
        double num2 = 6e+08;
        return (num1 + num2);
    }
    public static void main(String[] args)
    {
        FirstCode FC = new FirstCode();
        System.out.println(FC.sum());
    }
}

Output:

1.006E11

2. Using the strictfp with a class

public strictfp class FirstCode 
{
    public double difference()
    {
        double num1 = 10e+10;
        double num2 = 6e+08;
        return (num1 - num2);
    }
    public static void main(String[] args)
    {
        FirstCode FC = new FirstCode();
        System.out.println(FC.difference());
    }
}