Refactoring Conway's Game of Life in Java

I've recently revisited the Java version of Conway's Game of Life that I did nearly a year ago, to refactor it using some of the ideas I used in my more recent Clojure version.

This is the UML for the refactored design:

I eliminated the LivingCells class that appeared in the previous design.

I pushed a lot of code from the GameOfLife class into Generation to eliminate a bit of feature envy. This is GameOfLife's code now:

	package game;
	public class GameOfLife {
	private Generation currentGeneration;
	public GameOfLife(Generation initialGeneration) {
	this.currentGeneration = initialGeneration;
	}
	public void run(int steps) {
	currentGeneration = evolve(steps, currentGeneration);
	}
	private Generation evolve(int steps, Generation currentGeneration) {
	if (isOver(steps)) {
	return currentGeneration;
	}
	return evolve(
	steps - 1,
	currentGeneration.produceNextGeneration());
	}
	private boolean isOver(int steps) {
	return steps == 0 || currentGeneration.extinct();
	}
	public Generation currentGeneration() {
	return currentGeneration;
	}
	}

view raw GameOfLifeRefactored.java hosted with ❤ by GitHub

and this is Generation's one:

	package game;
	public class Generation {
	private Rules rules;
	private Cells aliveCells;
	public Generation(Rules rules, Cell... aliveCells) {
	this(rules, new Cells(aliveCells));
	}
	public Generation(Rules rules, Cells aliveCells) {
	this.rules = rules;
	this.aliveCells = aliveCells;
	}
	public Generation produceNextGeneration() {
	Cells nextGeneration = new Cells();
	for (Cell neighbor : aliveCells.getNeighbors()) {
	if (inNextGeneration(neighbor)) {
	nextGeneration.add(neighbor);
	}
	}
	return new Generation(rules, nextGeneration);
	}
	private boolean inNextGeneration(Cell neighbor) {
	return rules.inNextGeneration(
	isAlive(neighbor),
	aliveNeighborsNumberFor(neighbor));
	}
	private int aliveNeighborsNumberFor(Cell cell) {
	int res = 0;
	for (Cell neighbor : cell.neighbors()) {
	if (isAlive(neighbor)) {
	res++;
	}
	}
	return res;
	}
	private boolean isAlive(Cell cell) {
	return aliveCells.contains(cell);
	}
	public boolean extinct() {
	return aliveCells.empty();
	}
	@Override
	public boolean equals(Object obj) {
	if (this == obj)
	return true;
	if (obj == null)
	return false;
	if (getClass() != obj.getClass())
	return false;
	Generation other = (Generation) obj;
	if (aliveCells == null) {
	if (other.aliveCells != null)
	return false;
	} else if (!aliveCells.equals(other.aliveCells))
	return false;
	return true;
	}
	}

view raw GenerationRefactored.java hosted with ❤ by GitHub

I also refactored the tests eliminating all the checks based on strings and using constructors with variadic parameters.

Following the idea in the Clojure version I managed to simplify the Rules interface a lot:

	package game;
	public interface Rules {
	public boolean inNextGeneration(
	boolean alive,
	int numberOfNeighbors);
	}

view raw RulesRefactored.java hosted with ❤ by GitHub

Most of the other changes are just renaming of methods, variables and parameters.

This new code keeps the functionality and characteristics of the previous version but it's much simpler.