The following Java program can find any root of a whole number. The logic is simple. Start by guessing some number and check if that is the correct value. If that overshoots then subtract some from the guess number else add to it. We add or subtract some fixed constant. If that constant is too big then we divide that constant by 10 to get a finer number.

```
#!java
public class CubeRoot {
public static void main(String[] args) {
System.out.println(String.format("%.2f", cubeRoot(0, 2)));
System.out.println(String.format("%.0f", cubeRoot(8, 0)));
System.out.println(String.format("%.4f", cubeRoot(10, 4)));
System.out.println(String.format("%.4f", root(10, 2, 4))); // Square Root
System.out.println(String.format("%.4f", root(100, 5, 4))); // 5th Root
}
private static double cubeRoot(int n, int precision) {
return root(n, 3, precision);
}
private static double root(int n, int root, int precision) {
double x = n / 5.0; // 5 is better than 4 since this will have bigger
// step. 3 is very bad choice since there are some
// no.s which will never have rational output when
// divided by 3, e.g. 5.
double powX;
double d = 10;
double lastX = 0;
double lastLastX = 0;
do {
powX = Math.pow(x, root);
if (matches(powX, n, precision))
return x;
else {
if (matches(lastLastX, x, precision)) {
// If the lastLast x value is same as current then we are
// trapped in a loop, since the current d is not small
// enough. We need to now step at finer precisions.
d /= 10;
if (matches(d, 0, precision + 1)) {
return x;
}
}
lastLastX = lastX;
lastX = x;
if (n < powX) {
x -= d;
} else {
x += d;
}
// System.out.println("(x=" + x + ", d=" + d + ")");
}
} while (true);
}
private static boolean matches(double a, double b, int precession) {
return ((int) (a * (long) Math.pow(10, precession)))
- ((int) (b * (long) Math.pow(10, precession))) == 0;
}
}
```