【九宫】九宫的扩展，NxN，只适用于奇数。

package com.suikhan.game.shudu;
import java.awt.Point; 

/**
 * 【版权】开放源代码，可以用于包含商业应用的任意目的，
 *               但必须保留此段声明以及原作者名称。
 * 【作者】杨雨田
 * 【电邮】yangyutian@gmail.com
 * 【MSN】yangyutian@hotmail.com 
 * 
 * 【功能】九宫格，横加竖加对角加都相等。本处扩展为任意的NxN格（N为奇数）
 * 【版本】1.0
 */
public class NxN {
        private int n;                          //NxN中的N的个数
        private int[][] data;                   //用于存储矩阵数据
        private boolean[][] filled;             //存储对应的格子数据是否已经填充的信息
        private boolean debug = false;  //用于显示填充过程信息...

        /**
         * 构造函数
         * @param n NxN中的N的个数
         */
        public NxN(int n) {
                this(n,false);
        }

        /**
         * 构造函数
         * @param n NxN中的N的个数
         * @param debug 是否显示调试信息
         */
        public NxN(int n, boolean debug){
                super();
                this.n = n;
                this.debug = debug;
                this.fill();
        }

        /**
         * 设置坐标(x,y)处格子的值
         * @param x 横坐标
         * @param y 纵坐标
         * @param value 值
         */
        private void set(int x, int y, int value){
                if(debug){
                        System.out.println("Now is setting [" + (x + 1) + "," + (y + 1) + "] value ...");
                }
                data[x][y] = value;
                filled[x][y] = true;//true 表示数据已经添加
        }

        /**
         * 计算当前坐标点的下一个坐标点
         * @param pt 当前坐标点
         * @return 下一个坐标点
         */
        private Point next(Point pt){
                int x;
                int y;
                if((pt.x == n - 1)&&(pt.y == 0)){//如果在最右上角的格子，移动到他下面的格子
                        x = n - 1;
                        y = 1;
                }else{//否则，向右上方走一格
                        x = pt.x + 1;
                        y = pt.y - 1;
                        if(y < 0){//如果超出了上边界，转到列的最下端
                                y = n - 1;
                        }
                        if(x >= n){//若超出了右边界，转到行的最左端
                                x = 0;
                        }
                        if(filled[x][y]){//但是得到的格子已经有了数据
                                x = pt.x;
                                y = pt.y + 1;//向下移动一个格子
                        }
                }
                return new Point(x,y);

        }

        /**
         * 计算第一个坐标点
         * 一般是最上面一行中间的格子
         * @return 第一个坐标点
         */
        private Point first(){
                Point pt = new Point();
                pt.x = (n - 1) / 2;
                pt.y = 0;
                return pt;
        } 

        /**
         * 填充NxN矩阵
         */
        private void fill(){
                data = new int[n][n];
                filled = new boolean[n][n];
                Point pt = first();
                for(int i=1; i<=n*n; i++){
                        set(pt.x,pt.y,i);
                        pt = next(pt);
                }
        }

        public String toString(){
                StringBuilder sb = new StringBuilder();
                for(int y=0; y<n; y++){
                        for(int x=0; x<n; x++){
                                sb.append(data[x][y] + "/t");
                        }
                        sb.append("/n");
                }
                return sb.toString();
        }

        public static void main(String[] args) {
                NxN nxn = new NxN(3,true);
                System.out.println("=====================================");
                System.out.println(nxn.toString());
                System.out.println("=====================================");
        }
}