strictfp Keyword in Java

What strictfp Means

The name is short for "strict floating-point". It was added in Java 1.2 as a modifier you put on a class, interface or method to say: every float and double calculation in here must give exactly the result the IEEE 754 standard defines, bit for bit, on every machine. It never affects int, long or any other integer arithmetic.

The Problem It Solved: Different Results on Different CPUs

Java promises "write once, run anywhere", and that should include the same numbers. The x87 floating-point unit in older Intel processors, however, worked internally with 80-bit registers, wider than a 64-bit double. Forcing every intermediate result back to exact 64-bit double rules on that hardware was slow, so from Java 1.2 the JVM was allowed to keep intermediate results with a wider exponent range. A long calculation, especially one that briefly went past Double.MAX_VALUE or very close to zero, could then produce a slightly different answer on an x87 machine than on other hardware. strictfp was the opt-out: inside a strictfp method, the JVM had to use exact IEEE 754 single and double precision everywhere, so the result was identical on every platform.

IEEE 754 Floating-Point, Explained Simply

IEEE 754 is the international standard for storing and calculating with decimal-point numbers in binary. A double is 64 bits: 1 sign bit, 11 exponent bits and 52 bits of fraction, which gives roughly 15–17 significant decimal digits. A float is 32 bits with about 7 digits. Many decimals, such as 0.1, have no exact binary form, so 0.1 + 0.2 prints 0.30000000000000004 — on every JVM. strictfp never removed that rounding; it only guaranteed that the rounding happened in exactly the same way everywhere. For exact decimal arithmetic such as money, use BigDecimal.

Where strictfp Can Be Applied

strictfp can be applied to a class, an interface, or a method. Applying it to a class or interface makes every method body inside it strict, and that includes its nested and inner classes. It does not pass on to subclasses or to classes that implement a strictfp interface: their own methods follow their own declarations.

• strictfp class Calculator { ... } — every method in Calculator, and in classes nested inside it, uses strict floating-point rules.
• strictfp abstract class Shape { ... } — allowed; the concrete methods in Shape are strict.
• strictfp interface Scaler { ... } — the interface's own default and static method bodies are strict; implementing classes are not affected.
• public strictfp double computeArea() { ... } — only this method is constrained.

Where strictfp Is Not Allowed

strictfp describes how a method body computes, so it is only legal where there is a body or a type that contains bodies. The compiler rejects every other placement.

• Variables and fields: strictfp double x; gives "modifier strictfp not allowed here".
• Constructors: strictfp Point() {} gives the same error. Making the whole class strictfp covers its constructors.
• Abstract methods: strictfp abstract double area(); gives "illegal combination of modifiers: abstract and strictfp", because an abstract method has no body for the rule to apply to. The same goes for an abstract method declared in an interface.

Java 17 Change (JEP 306): Always Strict

By Java 17, every processor the JVM supports does floating-point through SSE2 or equivalent instructions, where exact IEEE 754 arithmetic is just as fast as the relaxed mode. JEP 306, "Restore Always-Strict Floating-Point Semantics", therefore made all floating-point operations strict by default — the JVM specification was updated so that strict IEEE 754 semantics apply everywhere, and the strictfp keyword became redundant. It is still legal to write, for backward compatibility, but javac 17 prints warning: [strictfp] as of release 17, all floating-point expressions are evaluated strictly and 'strictfp' is not required. In practice, this means you are unlikely to ever need to type strictfp in code targeting modern Java versions. It remains worth knowing, however, because it still appears in interview questions, certification exams, and in older Java 8/11-era codebases where it was meaningful.

Common Interview Questions

• What is strictfp? A modifier that forces float and double calculations to follow IEEE 754 exactly, so results are the same on every platform.
• When was it introduced? In Java 1.2.
• Where can strictfp be used? On classes (including abstract classes), interfaces and concrete methods.
• Can we use strictfp with abstract methods? No. abstract and strictfp is an illegal combination.
• Can an abstract class be strictfp? Yes.
• Can a variable or constructor be strictfp? No. Both are compile errors.
• Is strictfp inherited by subclasses? No. It applies to the declaring type and its nested types only.
• Is strictfp needed in Java 17+? No. All floating-point is strict by default since JEP 306, and the compiler warns that the keyword is redundant.

Examples

public strictfp class PrecisionCalculator {

    // Every floating-point operation inside a strictfp class/method
    // follows IEEE 754 rules consistently across all JVMs.
    public double multiply(double a, double b) {
        return a * b;
    }

    public static void main(String[] args) {
        PrecisionCalculator calc = new PrecisionCalculator();
        System.out.println(calc.multiply(1.1, 2.2));
    }
}

2.4200000000000004

public strictfp class StrictfpDemo {

    static double average(double... values) {
        double sum = 0;
        for (double v : values) {
            sum += v;
        }
        return sum / values.length;
    }

    public static void main(String[] args) {
        System.out.println(0.1 + 0.2);
        System.out.println(average(1.1, 2.2, 3.3));
        System.out.println(Double.MAX_VALUE * 2 / 2);   // overflows to Infinity under strict rules
        System.out.println(Math.ulp(1.0));
    }
}

0.30000000000000004
2.1999999999999997
Infinity
2.220446049250313E-16

Exercise

This program prints false, because 0.1 + 0.2 is not stored as exactly 0.3. Change the comparison so that it treats two doubles as equal when they differ by less than a very small tolerance.

Expected output: true

public class FloatCompare {
    public static void main(String[] args) {
        double sum = 0.1 + 0.2;
        System.out.println(sum == 0.3);
    }
}

public class FloatCompare {
    public static void main(String[] args) {
        double sum = 0.1 + 0.2;
        System.out.println(Math.abs(sum - 0.3) < 1e-9); // true
    }
}

Quick quiz

Interview questions