又重写Compass
next循环模式
变态模式
如有用到。。。。
请自行重构到能看懂再用。

return values()[((ordinal()+1)%(values().length))];

enum Compass{
	东(1,0),南(0,1),西(-1,0),北(0,-1);	
	int x,y;
	private Compass(int x, int y) {
		this.x = x ;
		this.y = y;
	}
	public void back(Point point) {
		point.translate(-x, -y);		
	}
	public void run(Point point){
		point.translate(x, y);
	}
        public Compass next(){
    	    return values()[((ordinal()+1)%(values().length))];
        }

}

占个座位回头看

为发扬抛哥的精神 小弟写了一个2维数组的迷宫版本 向大家请教 下面是我写的原创的地址
原创地址：http://chenyuxiaoxiao.iteye.com/blog/779322

import java.util.Arrays;
import java.util.Scanner;

public class Migong {

	/**
	 * 求迷宫的打印方法
	 * 01 02 03 04 05   00 01 02 03 04   5 4 4 3 3 2 2 1 1 //5阶迷宫每转一次湾 就要走的步数
	 * 16 17 18 19 06   10 11 12 13 14   4 3 3 2 2 1 1 //4阶迷宫每转一次湾 就要走的步数

	 * 15 24 25 20 07   20 21 22 23 24   3 2 2 1 1 //3阶迷宫每转一次湾 就要走的步数

	 * 14 23 22 21 08   30 31 32 33 34   2 1 1//2阶迷宫每转一次湾 就要走的步数

	 * 13 12 11 10 09   40 41 42 43 44   1//1阶迷宫每转一次湾 就要走的步数

	 */
	private static String[][] migong;
	private static Integer n;
	private static enum direct {
		left,right,up,down
	}
	public static void main(String[] args) {
		System.out.print("请输入迷宫的阶数：");
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		init_migong(n);
		//第一次走n 步  以后每两次转弯少走一步
		int step = n;
		int num = 1;
		int heng = 0; //横坐标
		int zong = 0; //纵坐标
		int upwan = 0;
		int leftwan = 0;
		//走的次数为  2 * n -1
		for(int i = 0 ;i<(2 * n -1);i++){
			String dir = next(i);
			if(dir.equals("right")){
				if(i==0){
					zong = 0;
				}else{
					zong = zong + 1;
				}
				for(int j = 1;j<= (step);j++){
					migong[heng][zong] = add_zero(num);
					zong++;
					num++;
				}
			}else if(dir.equals("down")){
				heng = heng + 1;
				zong = zong -1;
				for(int j = 1;j<= step;j++){
					migong[heng][zong] = add_zero(num);
					heng++;
					num++;
				}
			}else if(dir.equals("left")){
				heng = heng -1;
				zong = zong -1;
				for(int j = step;j>=1;j--){
					migong[heng][zong] = add_zero(num);
					zong--;
					if(1 == j){
						zong = leftwan;
					}
					num++;
				}
				leftwan = leftwan +1;
			}else if(dir.equals("up")){
				upwan = upwan +1;
				heng = heng -1;
				for(int j = step;j>=1;j--){
					migong[heng][zong] = add_zero(num);
					heng--;
					if(1 == j){
						heng = upwan;
					}
					num++;
				}
			}
			if(i%2==0){
				step = step -1;
			}
		}
		printmigong();
	}

	private static String next(int i){
		int mod = i % 4;
		String dir = "left";
		switch (mod) {
		case 0:
			dir = direct.right.toString();
			break;
		case 1:
			dir = direct.down.toString();
			break;
		case 2:
			dir = direct.left.toString();
			break;
		case 3:
			dir = direct.up.toString();
			break;
		}
		return dir;
	}
	private static String add_zero(Integer num){
		Integer temp = n * n;
		String s = temp.toString(); 
		Integer len = s.length();
		Integer l = num.toString().length();
		String zero = "";
		for(int i = 1;i<=len -l;i++ ){
			zero = zero + "0";
		}
		return zero + num; 
	}
	private static void printmigong(){
		for(int i = 0 ;i<migong.length;i++){
			System.out.println(Arrays.toString(migong[i]));
		}
	}
	private static void init_migong(Integer n) {
		migong = new String[n][n];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				migong[i][j] = "-1";
			}
		}
	}
}

什麼啊？這麼複雜的面試題，他以為他是微軟！？

这个写的有很多面向对象特征，不过用循环回溯更体现算法的思想，而且更简洁直观，因为这种题相当于一个小功能而不是一个功能模块。开发中也这样做吗？

算法的好处是你只需要写出最好的.....就可以
但事实上现实中代码是在不得的变化的
需求也在变化.
数据结构也在变化.

看看我指南针的写法变化....

面向对象不过是一屏写不下的情况下
没什么人可以全局把握代码.

分成多个元素每个元素
每个元素内的代码可以自解释.

一个故事 + OO + 测试先行，描述转圈打印的算法，抛哥费心了。