interface StartTask {
	double initState();
}

interface LoopTask {
	double nextState(double state);
}

interface TestTask {
	boolean isGoal(double state);
}

interface EndTask {
	void displayState(double state);
}

interface TaskFactory {
	StartTask makeStartTask();
	LoopTask makeLoopTask();
	TestTask makeTestTask();
	EndTask makeEndTask();
}

public class Process {
	private StartTask task1;
	private LoopTask task2;
	private TestTask task3;
	private EndTask task4;
	private double state;
	public void execute() {
		state = task1.initState();
		while (!task3.isGoal(state)) {
			state = task2.nextState(state);
		}
		task4.displayState(state);
	}
	public Process(TaskFactory f) {
		task1 = f.makeStartTask();
		task2 = f.makeLoopTask();
		task3 = f.makeTestTask();
		task4 = f.makeEndTask();
	}

	public static void main(String[] args) {
		Process p = new Process(new RootFactory());
		p.execute();
	}
	// etc,
}

class RootInit implements StartTask {
	public double initState() {
		return 1.0;
	}
}
class RootLoop implements LoopTask {
	private double n;
	public RootLoop(double n) {
		this.n = n;
	}
	public double nextState(double state) {
		// Newton's method:
		return state - (state * state - n)/(2 * state);
	}
}
class RootTest implements TestTask {
	private double n;
	public RootTest(double n) {
		this.n = n;
	}
	public boolean isGoal(double state) {
		return Math.abs(state * state - n) <= 1e-4;
	}
}
class RootEnd implements EndTask {
	public void displayState(double state) {
		System.out.println("root = " + state);
	}
}

class RootFactory implements TaskFactory {
	public StartTask makeStartTask() {
		return new RootInit();
	}
	public LoopTask makeLoopTask() {
		return new RootLoop(100);
	}

	public TestTask makeTestTask() {
		return new RootTest(100);
	}
	public EndTask makeEndTask() {
		return new RootEnd();
	}
}