Java by Contract is an implementation of Design by Contract, as promoted by Bertrand Meyer and the Eiffel Software company, for the Java programming language. The contract is specified using standard Java methods and annotations, making it a more reliable tool than earlier work which used javadoc comments and rewrote the Java source code to include the relevant tests.

Which is all well and good, but how do you *use* it? Here’s an example.

## The problem

There is a whole class of algorithms to approximately find roots to a function, using an iterative technique. Given, in Java syntax, the abstract type `MathFunction`

that implements a function over the `double`

type:

```
interface MathFunction {
double f(double x);
}
```

Define the abstract interface that exposes such an iterative solution, including the details of its contract.

## The solution

The interface is designed using the Command-Query Separation Principle. Given access to the function `f()`

, the interface has a command `findRoot(seed1, seed2)`

which locates the root between those two values, and a query `root()`

which returns that root. Additionally, a boolean query `exhaustedIterations()`

reports whether the solution converged.

Both of the queries have the precondition that the command must previously have successfully run; i.e. you cannot ask what the answer was without requesting that the answer be discovered.

The contract on the command is more interesting. The precondition is that for the two seed values `seed1`

and `seed2`

, one of them must correspond to a point `f(x) > 0`

and the other to a point `f(x) < 0`

(it does not matter which). This guarantees an odd, and therefore non-zero, number of roots[*] to `f(x)`

between the two, and the method will iterate toward one of them. If the precondition does not hold, then an even number of roots (including possibly zero) lies between the seed values, so it cannot be guaranteed that a solution exists to find.

In return for satisfying the precondition, the command guarantees that it either finds a root or exhausts its iteration allowance looking. Another way of putting that: if the method exits early, it is *because* it has already found a convergent solution.

Many, but not all, of these contract details can be provided as default method implementations in the interface. The remainder must be supplied by the implementing class.

```
/**
* Given a mathematical function f over the doubles, and two bounds for a root to that function,
* find the root using an (unspecified) iterative approach.
* A root is an input value x such that f(x)=0.
*/
public interface RootFinder {
/**
* @return The function that this object is finding a root for.
*/
MathFunction f();
/**
* A root to the function f() is thought to lie between seed1 and seed2. Find it.
* @param seed1 One boundary for the root to f().
* @param seed2 Another boundary for the root to f().
*/
@Precondition(name = "seedGuessesStraddleRoot")
@Postcondition(name = "earlyExitImpliesConvergence")
void findRoot(double seed1, double seed2);
/**
* @return The root to the function f() that was discovered.
*/
@Precondition(name = "guessWasCalculated")
Double root();
/**
* @return Whether the iterative solution used the maximum number of iterations.
*/
@Precondition(name = "guessWasCalculated")
boolean exhaustedIterations();
default Boolean guessWasCalculated() {
return this.root() != null;
}
default Boolean seedGuessesStraddleRoot(Double seed1, Double seed2) {
double r1 = f().f(seed1);
double r2 = f().f(seed2);
return ((r1 > 0 && r2 < 0) || (r1 < 0 && r2 > 0));
}
Boolean earlyExitImpliesConvergence(Double seed1, Double seed2, Void result);
}
```

## Example usage

There are swaths of algorithms to implement this interface. See, for example, the book Numerical Recipes. Given a particular implementation, we can look for roots of a simple function, for example `f(x) = x^2 - 2`

:

```
RootFinder squareRootOfTwo = SecantRootFinder.finderForFunction((double x) -> x*x - 2);
squareRootOfTwo.findRoot(1.0, 2.0);
System.out.println(String.format("Root: %f", squareRootOfTwo.root()));
System.out.println(String.format("The solution did%s converge before hitting the iteration limit",
squareRootOfTwo.exhaustedIterations()?"n't":""));
```

This suggests that a root exists at x~=1.414214, and that it converged on the solution before running out of goes. Let’s see if there’s another root between 2 and 3:

```
Exception in thread "main" online.labrary.javaByContract.ContractViolationException:
online.labrary.javaByContract.Precondition seedGuessesStraddleRoot had unexpected value false on object
online.labrary.jbcTests.TestGeneratorTests$SecantRootFinder@29774679
at javaByContract/online.labrary.javaByContract.ContractEnforcer.invoke(ContractEnforcer.java:92)
at jdk.proxy1/com.sun.proxy.jdk.proxy1.$Proxy4.findRoot(Unknown Source)
at javaByContract/online.labrary.rootFinder.RootFinder.main(RootFinder.java:10)
```

Whoops! I’m holding it wrong: the function doesn’t change sign between x=2 and x=3. I shouldn’t expect the tool to work, and indeed it’s been designed to *communicate* that expectation by failing a precondition.

[*] Nitpick: roots _or singularities_.