Programmierwettbewerb 2: Aaah a snake!

[src=java]public class Pathfinder {

/**
*
*/
private Point start;

/**
*
*/
private Point destination;

/**
*
*/
private int xMax = 1;

/**
*
*/
private int yMax = 1;

/**
*
*/
private int hasPath = -1;

/**
*
*/
private ArrayList<Point> barrier;

public Pathfinder(Point start, Point destination, int xMax, int yMax, ArrayList<Point> barrier) {
this.start = start;
this.destination = destination;
this.xMax = xMax;
this.yMax = yMax;
this.barrier = barrier;
}

/**
*
*/
private void findPath() {
if(this.findPath(this.start, null)) {
this.hasPath = 1;
} else {
this.hasPath = 0;
}
}

//Debug
private int i;
/**
*
* @param startPosition
* @param previousPoint
* @return
*/
private boolean findPath(Point startPosition, ArrayList<Point> previousPoints) {
ArrayList<Point> nextPoints = this.getPointsAround(startPosition, previousPoints);
if(previousPoints == null) {
previousPoints = new ArrayList<>();
}


i++;
System.out.println(i);


if(nextPoints.contains(this.destination)) {
return true;
} else {
if(!previousPoints.contains(startPosition)) {
previousPoints.add(startPosition);
}

for(Point p: nextPoints) {
if(this.findPath(p, (ArrayList<Point>) previousPoints)) {
return true;
}
}
return false;
}
}

public boolean hasPath() {
if(this.hasPath == -1) {
this.findPath();
}
if(this.hasPath == 0) {
return false;
} else {
return true;
}
}

/**
*
* @param p
* @param previousPoint can be null
* @return
*/
private ArrayList<Point> getPointsAround(Point p, ArrayList<Point> previousPoints) {
ArrayList<Point> pointsAround = new ArrayList<>();
if(previousPoints == null) {
previousPoints = new ArrayList<>();
}

if (p.x - 1 >= 0 && !this.barrier.contains(new Point(p.x - 1, p.y))
&& !previousPoints.contains(new Point(p.x-1, p.y))) {
pointsAround.add(new Point(p.x-1, p.y));
}
if (p.x + 1 <= this.xMax && !this.barrier.contains(new Point(p.x + 1, p.y))
&& !previousPoints.contains(new Point(p.x+1, p.y))) {
pointsAround.add(new Point(p.x+1, p.y));
}
if (p.y - 1 >= 0 && !this.barrier.contains(new Point(p.x, p.y - 1))
&& !previousPoints.contains(new Point(p.x, p.y-1))) {
pointsAround.add(new Point(p.x, p.y-1));
}
if (p.y + 1 <= this.yMax && !this.barrier.contains(new Point(p.x, p.y + 1))
&& !previousPoints.contains(new Point(p.x, p.y+1))) {
pointsAround.add(new Point(p.x, p.y+1));
}

return pointsAround;
}[/src]

Kann mir jemand sagen, wieso bei einem "leeren" Feld (auf dem nur ein Fresspunkt und die Schlange, mit Länge 1) der erste Punkt bereits "keine Verbindung" hat?
Es werden etwa 4200 Male die findPath-Methode aufgerufen. (Bei ca. 50x40), aber es kommt immer "keine Verbindung (hasPath = 0) raus. Das verstehe ich einfach nicht. Ich weiß jetzt auch nicht mehr, wie ich das testen soll...

Ich habe das deswegen erstmal ausgelagert, damit ich getrennt davon arbeiten kann.