Java+Swing实现经典五子棋游戏

目录

• 前言
• 主要需求
• 主要设计
• 功能截图
• 代码实现
• 总结

前言

五子棋是世界智力运动会竞技项目之一，是一种两人对弈的纯策略型棋类游戏，是世界智力运动会竞技项目之一，通常双方分别使用黑白两色的棋子，下在棋盘直线与横线的交叉点上，先形成5子连线者获胜。

棋具与围棋通用，起源于中国上古时代的传统黑白棋种之一。主要流行于华人和汉字文化圈的国家以及欧美一些地区，是世界上最古老的棋。

容易上手，老少皆宜，而且趣味横生，引人入胜；不仅能增强思维能力，提高智力，而且富含哲理，有助于修身养性。

用java语言实现，采用了swing技术进行了界面化处理，设计思路用了面向对象思想。

主要需求

1、对局双方各执一色棋子。

2、空棋盘开局。

3、黑先、白后，交替下子，每次只能下一子。

4、棋子下在棋盘的空白点上，棋子下定后，不得向其它点移动，不得从棋盘上拿掉或拿起另落别处。

5、黑方的第一枚棋子可下在棋盘任意交叉点上。

6、轮流下子是双方的权利，但允许任何一方放弃下子权，先形成5子连线者获胜。

主要设计

1、由于是两人的游戏，非单机版，所以要有多个客户端相互通信，这时就要用到socket 技术

2、设计socket服务端，用来维护socket客户端连接

3、设计socket客户端，用来实现五子棋逻辑和效果

4、客户端要能设置连接服务端的IP，用来连接服务端

5、客户端1创建游戏后，客户端2可以选择客户端1进行联机对战

6、游戏规则：

• 对局双方各执一色棋子。
• 空棋盘开局。
• 黑先、白后，交替下子，每次只能下一子。
• 棋子下在棋盘的空白点上，棋子下定后，不得向其它点移动，不得从棋盘上拿掉或拿起另落别处。
• 黑方的第一枚棋子可下在棋盘任意交叉点上。
• 轮流下子是双方的权利，但允许任何一方放弃下子权，先形成5子连线者获胜。

功能截图

服务端启动

客户端1启动

客户端2启动

对战效果

代码实现

服务端启动类

public class ServerRunner extends Frame implements ActionListener {
    JButton clearMsgButton = new JButton("清空");
    JButton serverStatusButton = new JButton("状态");
    JButton closeServerButton = new JButton("关闭");
    Panel buttonPanel = new Panel();
    ServerMsgPanel serverMsgPanel = new ServerMsgPanel();
    ServerSocket serverSocket;
    int clientAccessNumber = 1;

    /**
     * 将客户端套接口和输出流绑定
     */
    Hashtable clientDataHash = new Hashtable(50);
    /**
     * 将客户端套接口和客户名绑定
     */
    Hashtable clientNameHash = new Hashtable(50);
    /**
     * 将游戏创建者和游戏加入者绑定
     */
    Hashtable chessPeerHash = new Hashtable(50);

    public ServerRunner() {
        super("网络游戏对战平台服务器控制平台");
        setBackground(Color.PINK);
        buttonPanel.setLayout(new FlowLayout());
        clearMsgButton.setSize(50, 30);
        buttonPanel.add(clearMsgButton);
        clearMsgButton.addActionListener(this);
        serverStatusButton.setSize(50, 30);
        buttonPanel.add(serverStatusButton);
        serverStatusButton.addActionListener(this);
        closeServerButton.setSize(50, 30);
        buttonPanel.add(closeServerButton);
        closeServerButton.addActionListener(this);
        add(serverMsgPanel, BorderLayout.CENTER);
        add(buttonPanel, BorderLayout.SOUTH);

        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        pack();
        setVisible(true);
        setSize(600, 440);
        setResizable(false);
        validate();

        try {
            createServer(1234, serverMsgPanel);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 用指定端口和面板创建服务器
     * @param port
     * @param serverMsgPanel
     * @throws IOException
     */
    public void createServer(int port, ServerMsgPanel serverMsgPanel) throws IOException {
        // 客户端套接口
        Socket clientSocket;
        // 设定当前主机
        this.serverMsgPanel = serverMsgPanel;
        try {
            serverSocket = new ServerSocket(port);
            serverMsgPanel.msgTextArea.setText("服务器启动:"
                    + InetAddress.getLocalHost() + ":"
                    + serverSocket.getLocalPort() + "\n");
            while (true) {
                // 监听客户端套接口的信息 
                clientSocket = serverSocket.accept();
                serverMsgPanel.msgTextArea.append("已连接用户:" +
                        "毅慎" + clientAccessNumber +"\n" + clientSocket + "\n");
                // 建立客户端输出流 
                DataOutputStream outputData = new DataOutputStream(clientSocket.getOutputStream());
                // 将客户端套接口和输出流绑定 
                clientDataHash.put(clientSocket, outputData);
                // 将客户端套接口和客户名绑定 
                clientNameHash.put(clientSocket, ("毅慎" + clientAccessNumber++));
                // 创建并运行服务器端线程 
                ServerThread thread = new ServerThread(clientSocket,
                        clientDataHash, clientNameHash, chessPeerHash, serverMsgPanel);
                thread.start();
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        // 清空服务器信息
        if (e.getSource() == clearMsgButton) {
            serverMsgPanel.msgTextArea.setText("");
        }

        // 显示服务器信息
        if (e.getSource() == serverStatusButton) {
            try {
                serverMsgPanel.msgTextArea.append("用户信息：" + "毅慎"
                        + (clientAccessNumber - 1) + "\n服务器信息:"
                        + InetAddress.getLocalHost() + ":"
                        + serverSocket.getLocalPort() + "\n");
            } catch (Exception ee) {
                ee.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        new ServerRunner();
    }
    
}

客户端启动类

/**
 * @Author: Mr_OO
 * @Date: 2019/12/22 9:05
 * 客户端
 */
public class ClientChess extends Frame implements ActionListener, KeyListener {

    /**
     * 客户端套接口
     */
    public Socket clientSocket;

    /**
     * 数据输入流
     */
    public DataInputStream inputStream;

    /**
     * 数据输出流
     */
    public DataOutputStream outputStream;

    /**
     * 用户名
     */
    public String chessClientName = null;
    /**
     * 主机地址 
     */
    public String host = null;
    /**
     * 主机端口
     */
    public int port = 1234;
    /**
     * 是否在聊天
     */
    public boolean isOnChat = false;
    /**
     * 是否在下棋
     */
    public boolean isOnChess = false;
    /**
     * 游戏是否进行中
     */
    public boolean isGameConnected = false;
    /**
     * 是否为游戏创建者
     */
    public boolean isCreator = false;
    /**
     * 是否为游戏加入者
     */
    public boolean isParticipant = false;
    /**
     * 用户列表区
     */
    public UserList userListPad = new UserList();
    /**
     * 用户聊天区
     */
    protected UserChat userChatPad = new UserChat();
    /**
     * 用户操作区
     */
    public UserController userControlPad = new UserController();
    /**
     * 用户输入区
     */
    protected UserInput userInputPad = new UserInput();
    /**
     * 下棋区
     */
    ChessBoard chessBoard = new ChessBoard();
    /**
     * 面板区
     */
    private Panel southPanel = new Panel();
    private Panel centerPanel = new Panel();
    private Panel eastPanel = new Panel();

    /**
     * 构造方法，创建界面
     */
    public ClientChess() {
        super("五子棋客户端");
        setLayout(new BorderLayout());
        host = userControlPad.ipInputted.getText();
        
        eastPanel.setLayout(new BorderLayout());
        eastPanel.add(userListPad, BorderLayout.NORTH);
        eastPanel.add(userChatPad, BorderLayout.CENTER);
        eastPanel.setBackground(new Color(238, 154, 73));

        userInputPad.contentInputted.addKeyListener(this);

        chessBoard.host =  (userControlPad.ipInputted.getText());
        centerPanel.add(chessBoard, BorderLayout.CENTER);
        centerPanel.add(userInputPad, BorderLayout.SOUTH);
        centerPanel.setBackground(new Color(238, 154, 73));
        userControlPad.connectButton.addActionListener(this);
        userControlPad.createButton.addActionListener(this);
        userControlPad.joinButton.addActionListener(this);
        userControlPad.cancelButton.addActionListener(this);
        userControlPad.exitButton.addActionListener(this);
        userControlPad.createButton.setEnabled(false);
        userControlPad.joinButton.setEnabled(false);
        userControlPad.cancelButton.setEnabled(false);

        southPanel.add(userControlPad, BorderLayout.CENTER);
        southPanel.setBackground(PINK);

        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                // 聊天中
                if (isOnChat) {
                    // 关闭客户端套接口
                    try {
                        clientSocket.close();
                    }
                    catch (Exception ed){}
                }

                if (isOnChess || isGameConnected) {
                    // 下棋中 
                    try {
                        // 关闭下棋端口 
                        chessBoard.chessSocket.close();
                    }
                    catch (Exception ee){}
                }
                System.exit(0);
            }
        });

        add(eastPanel, BorderLayout.EAST);
        add(centerPanel, BorderLayout.CENTER);
        add(southPanel, BorderLayout.SOUTH);
        pack();
        setSize(1000, 700);
        setVisible(true);
        setResizable(false);
        this.validate();
    }

    /**
     * 按指定的IP地址和端口连接到服务器
     * @param serverIP
     * @param serverPort
     * @return
     * @throws Exception
     */
    public boolean connectToServer(String serverIP, int serverPort) throws Exception {
        try {
            // 创建客户端套接口 
            clientSocket = new Socket(serverIP, serverPort);
            // 创建输入流 
            inputStream = new DataInputStream(clientSocket.getInputStream());
            // 创建输出流 
            outputStream = new DataOutputStream(clientSocket.getOutputStream());
            // 创建客户端线程 
            ClientThread clientThread = new ClientThread(this);
            // 启动线程，等待聊天信息 
            clientThread.start();
            isOnChat = true;
            return true;
        } catch (IOException ex) {
            userChatPad.chatTextArea.setText("Sorry,无法连接!!!\n");
        }
        return false;
    }

    /**
     * 客户端事件处理
     * @param e
     */
    @Override
    public void actionPerformed(ActionEvent e) {

        // 连接到主机按钮单击事件
        if (e.getSource() == userControlPad.connectButton) {
            // 取得主机地址
            host = chessBoard.host = userControlPad.ipInputted.getText();
            try {
                // 成功连接到主机时，设置客户端相应的界面状态
                if (connectToServer(host, port)) {
                    userChatPad.chatTextArea.setText("");
                    userControlPad.connectButton.setEnabled(false);
                    userControlPad.createButton.setEnabled(true);
                    userControlPad.joinButton.setEnabled(true);
                    chessBoard.statusText.setText("连接成功，请等待!!!");
                }
            } catch (Exception ei) {
                userChatPad.chatTextArea.setText("Sorry,不能连接!!!\n");
            }
        }

        // 离开游戏按钮单击事件
        if (e.getSource() == userControlPad.exitButton) {
            // 若用户处于聊天状态中
            if (isOnChat) {
                try {
                    // 关闭客户端套接口 
                    clientSocket.close();
                }
                catch (Exception ed){}
            }

            // 若用户处于游戏状态中 
            if (isOnChess || isGameConnected) {
                try {
                    // 关闭游戏端口 
                    chessBoard.chessSocket.close();
                }
                catch (Exception ee){}
            }
            System.exit(0);
        }

        // 加入游戏按钮单击事件
        if (e.getSource() == userControlPad.joinButton) {
            // 取得要加入的游戏
            String selectedUser = userListPad.userList.getSelectedItem();
            // 若未选中要加入的用户，或选中的用户已经在游戏，则给出提示信息 
            if (selectedUser == null || selectedUser.startsWith("[inchess]") ||
                    selectedUser.equals(chessClientName)) {
                chessBoard.statusText.setText("必须选择一个用户!");
            } else {
                // 执行加入游戏的操作 
                try {
                    // 若游戏套接口未连接
                    if (!isGameConnected) {
                        // 若连接到主机成功
                        if (chessBoard.connectServer(chessBoard.host, chessBoard.port)) {
                            isGameConnected = true;
                            isOnChess = true;
                            isParticipant = true;
                            userControlPad.createButton.setEnabled(false);
                            userControlPad.joinButton.setEnabled(false);
                            userControlPad.cancelButton.setEnabled(true);
                            chessBoard.chessThread.sendMessage("/joingame "
                                    + userListPad.userList.getSelectedItem() + " "
                                    + chessClientName);
                        }
                    } else {
                        // 若游戏端口连接中 
                        isOnChess = true;
                        isParticipant = true;
                        userControlPad.createButton.setEnabled(false);
                        userControlPad.joinButton.setEnabled(false);
                        userControlPad.cancelButton.setEnabled(true);
                        chessBoard.chessThread.sendMessage("/joingame "
                                + userListPad.userList.getSelectedItem() + " "
                                + chessClientName);
                    }
                } catch (Exception ee) {
                    isGameConnected = false;
                    isOnChess = false;
                    isParticipant = false;
                    userControlPad.createButton.setEnabled(true);
                    userControlPad.joinButton.setEnabled(true);
                    userControlPad.cancelButton.setEnabled(false);
                    userChatPad.chatTextArea.setText("不能连接: \n" + ee);
                }
            }
        }

        // 创建游戏按钮单击事件 
        if (e.getSource() == userControlPad.createButton) {
            try {
                // 若游戏端口未连接
                if (!isGameConnected) {
                    if (chessBoard.connectServer(chessBoard.host, chessBoard.port)) {
                        // 若连接到主机成功 
                        isGameConnected = true;
                        isOnChess = true;
                        isCreator = true;
                        userControlPad.createButton.setEnabled(false);
                        userControlPad.joinButton.setEnabled(false);
                        userControlPad.cancelButton.setEnabled(true);
                        chessBoard.chessThread.sendMessage("/creatgame " + "[inchess]" + chessClientName);
                    }
                } else {
                    // 若游戏端口连接中 
                    isOnChess = true;
                    isCreator = true;
                    userControlPad.createButton.setEnabled(false);
                    userControlPad.joinButton.setEnabled(false);
                    userControlPad.cancelButton.setEnabled(true);
                    chessBoard.chessThread.sendMessage("/creatgame "
                            + "[inchess]" + chessClientName);
                }
            } catch (Exception ec) {
                isGameConnected = false;
                isOnChess = false;
                isCreator = false;
                userControlPad.createButton.setEnabled(true);
                userControlPad.joinButton.setEnabled(true);
                userControlPad.cancelButton.setEnabled(false);
                ec.printStackTrace();
                userChatPad.chatTextArea.setText("Sorry,不能连接: \n" + ec);
            }
        }

        // 退出游戏按钮单击事件 
        if (e.getSource() == userControlPad.cancelButton) {
            // 游戏中
            if (isOnChess) {
                chessBoard.chessThread.sendMessage("/giveup " + chessClientName);
                chessBoard.setVicStatus(-1 * chessBoard.chessColor);
                userControlPad.createButton.setEnabled(true);
                userControlPad.joinButton.setEnabled(true);
                userControlPad.cancelButton.setEnabled(false);
                chessBoard.statusText.setText("请选择创建房间或加入游戏!!!");
            } if (!isOnChess) {
                // 非游戏中 
                userControlPad.createButton.setEnabled(true);
                userControlPad.joinButton.setEnabled(true);
                userControlPad.cancelButton.setEnabled(false);
                chessBoard.statusText.setText("请选择创建房间或加入游戏!!!");
            }
            isParticipant = isCreator = false;
        }
    }

    @Override
    public void keyPressed(KeyEvent e) {
        TextField inputwords = (TextField) e.getSource();
        // 处理回车按键事件
        if (e.getKeyCode() == KeyEvent.VK_ENTER) {
            // 给所有人发信息 
            if (userInputPad.userChoice.getSelectedItem().equals("所有用户")) {
                try {
                    // 发送信息 
                    outputStream.writeUTF(inputwords.getText());
                    inputwords.setText("");
                } catch (Exception ea) {
                    userChatPad.chatTextArea.setText("Sorry,不能连接到服务器!\n");
                    userListPad.userList.removeAll();
                    userInputPad.userChoice.removeAll();
                    inputwords.setText("");
                    userControlPad.connectButton.setEnabled(true);
                }
            } else {
                // 给指定人发信息 
                try {
                    outputStream.writeUTF("/" + userInputPad.userChoice.getSelectedItem()
                            + " " + inputwords.getText());
                    inputwords.setText("");
                } catch (Exception ea) {
                    userChatPad.chatTextArea.setText("Sorry,不能连接到服务器!\n");
                    userListPad.userList.removeAll();
                    userInputPad.userChoice.removeAll();
                    inputwords.setText("");
                    userControlPad.connectButton.setEnabled(true);
                }
            }
        }
    }

    @Override
    public void keyTyped(KeyEvent e) {}

    @Override
    public void keyReleased(KeyEvent e) {}

    public static void main(String[] args) {
        new ClientChess();
    }
}

棋盘五子棋核心算法类

public class ChessBoard extends Panel implements MouseListener, ActionListener {
    public int dis = 30;
    // 鼠标是否能使用 
    public boolean isMouseEnabled = false;
    // 是否胜利 
    public boolean isWon = false;
    // 棋子的x轴坐标位 
    public int chessX_POS = -1;
    // 棋子的y轴坐标位 
    public int chessY_POS = -1;
    // 棋子的颜色 
    public int chessColor = 1;
    // 黑棋x轴坐标位数组 
    public int chessBlack_XPOS[] = new int[200];
    // 黑棋y轴坐标位数组 
    public int chessBlack_YPOS[] = new int[200];
    // 白棋x轴坐标位数组 
    public int chessWhite_XPOS[] = new int[200];
    // 白棋y轴坐标位数组 
    public int chessWhite_YPOS[] = new int[200];
    // 黑棋数量 
    public int chessBlackCount = 0;
    // 白棋数量 
    public int chessWhiteCount = 0;
    // 黑棋获胜次数 
    public int chessBlackVicTimes = 0;
    // 白棋获胜次数 
    public int chessWhiteVicTimes = 0;
    // 套接口 
    public Socket chessSocket;
    protected DataInputStream inputData;
    protected DataOutputStream outputData;
    public String chessSelfName = null;
    public String chessPeerName = null;
    public String host = null;
    public int port = 1234;
    public TextField statusText = new TextField("请先连接服务器！！！");
    public ChessThread chessThread = new ChessThread(this);

    public ChessBoard() {
        setSize(600, 600);
        setLayout(null);
        setBackground(new Color(205, 133, 63));
        addMouseListener(this);
        add(statusText);
        statusText.setBounds(new Rectangle(80, 5, 440, 24));
        statusText.setEditable(false);
    }

    /**
     * 连接到主机
     * @param ServerIP
     * @param ServerPort
     * @return
     * @throws Exception
     */
    public boolean connectServer(String ServerIP, int ServerPort) throws Exception {
        try {
            // 取得主机端口 
            chessSocket = new Socket(ServerIP, ServerPort);
            // 取得输入流 
            inputData = new DataInputStream(chessSocket.getInputStream());
            // 取得输出流 
            outputData = new DataOutputStream(chessSocket.getOutputStream());
            chessThread.start();
            return true;
        } catch (IOException ex) {
            statusText.setText("sorry，连接失败!!! \n");
        }
        return false;
    }

    /**
     * 设定胜利时的棋盘状态
     * @param vicChessColor
     */
    public void setVicStatus(int vicChessColor) {
        // 清空棋盘 
        this.removeAll();
        // 将黑棋的位置设置到零点 
        for (int i = 0; i <= chessBlackCount; i++) {
            chessBlack_XPOS[i] = 0;
            chessBlack_YPOS[i] = 0;
        }
        // 将白棋的位置设置到零点 
        for (int i = 0; i <= chessWhiteCount; i++) {
            chessWhite_XPOS[i] = 0;
            chessWhite_YPOS[i] = 0;
        }
        // 清空棋盘上的黑棋数 
        chessBlackCount = 0;
        // 清空棋盘上的白棋数 
        chessWhiteCount = 0;
        add(statusText);
        statusText.setBounds(40, 5, 200, 24);
        // 黑棋胜
        if (vicChessColor == 1) {
            chessBlackVicTimes++;
            statusText.setText("恭喜黑方胜！！！黑VS白 " + chessBlackVicTimes + ":" + chessWhiteVicTimes
                    + ".游戏重启，等待白方...");
            // 白棋胜
        } else if (vicChessColor == -1) {
            chessWhiteVicTimes++;
            statusText.setText("恭喜白方胜！！！黑VS白 " + chessBlackVicTimes + ":" + chessWhiteVicTimes
                    + ".游戏重启,等待黑方...");
        }
    }

    /**
     * 取得指定棋子的位置
     * @param xPos
     * @param yPos
     * @param chessColor
     */
    public void setLocation(int xPos, int yPos, int chessColor) {
        // 棋子为黑棋时
        if (chessColor == 1) {
            chessBlack_XPOS[chessBlackCount] = xPos * dis;
            chessBlack_YPOS[chessBlackCount] = yPos * dis;
            chessBlackCount++;
        // 棋子为白棋时
        } else if (chessColor == -1) {
            chessWhite_XPOS[chessWhiteCount] = xPos * dis;
            chessWhite_YPOS[chessWhiteCount] = yPos * dis;
            chessWhiteCount++;
        }
    }

    /**
     * 五子棋核心算法
     * @param xPos
     * @param yPos
     * @param chessColor
     * @return
     */
    public boolean checkVicStatus(int xPos, int yPos, int chessColor) {
        // 连接棋子数
        int chessLinkedCount = 1;
        // 用于比较是否要继续遍历一个棋子的相邻网格 
        int chessLinkedCompare = 1;
        // 要比较的棋子在数组中的索引位置
        int chessToCompareIndex = 0;
        // 相邻网格的位置
        int closeGrid = 1;
        // 黑棋时
        if (chessColor == 1) {
            // 将该棋子自身算入的话，初始连接数为1
            chessLinkedCount = 1;
            //以下每对for循环语句为一组，因为下棋的位置能位于中间而非两端
            
            // 遍历相邻4个网格
            // 判断当前下的棋子的右边4个棋子是否都为黑棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                // 遍历棋盘上所有黑棋子
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
                    if (((xPos + closeGrid) * dis == chessBlack_XPOS[chessToCompareIndex])
                            && ((yPos * dis) == chessBlack_YPOS[chessToCompareIndex])) {
                        // 连接数加1 
                        chessLinkedCount = chessLinkedCount + 1;
                        // 五子相连时，胜利 
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                    // 若中间有一个棋子非黑棋，则会进入此分支，此时无需再遍历
                } else {
                    break;
                }
            }
            
            // 判断当前下的棋子的左边4个棋子是否都为黑棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
                    if (((xPos - closeGrid) * dis == chessBlack_XPOS[chessToCompareIndex])
                            && (yPos * dis == chessBlack_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            // 进入新的一组for循环时要将连接数等重置 
            chessLinkedCount = 1;
            chessLinkedCompare = 1;
            // 判断当前下的棋子的上边4个棋子是否都为黑棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
                    if ((xPos * dis == chessBlack_XPOS[chessToCompareIndex])
                            && ((yPos + closeGrid) * dis == chessBlack_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }
            
            // 判断当前下的棋子的下边4个棋子是否都为黑棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
                    if ((xPos * dis == chessBlack_XPOS[chessToCompareIndex])
                            && ((yPos - closeGrid) * dis == chessBlack_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            chessLinkedCount = 1;
            chessLinkedCompare = 1;
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
                    // 判断当前下的棋子的左上方向4个棋子是否都为黑棋 
                    if (((xPos - closeGrid) * dis == chessBlack_XPOS[chessToCompareIndex])
                            && ((yPos + closeGrid) * dis == chessBlack_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
                    // 判断当前下的棋子的右下方向4个棋子是否都为黑棋 
                    if (((xPos + closeGrid) * dis == chessBlack_XPOS[chessToCompareIndex])
                            && ((yPos - closeGrid) * dis == chessBlack_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            chessLinkedCount = 1;
            chessLinkedCompare = 1;
            // 判断当前下的棋子的右上方向4个棋子是否都为黑棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
                    if (((xPos + closeGrid) * dis == chessBlack_XPOS[chessToCompareIndex])
                            && ((yPos + closeGrid) * dis == chessBlack_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }
            
            // 判断当前下的棋子的左下方向4个棋子是否都为黑棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
                    if (((xPos - closeGrid) * dis == chessBlack_XPOS[chessToCompareIndex])
                            && ((yPos - closeGrid) * dis == chessBlack_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }
        // 白棋的情况 
        } else if (chessColor == -1) {
            chessLinkedCount = 1;
            // 判断当前下的棋子的右边4个棋子是否都为白棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
                    if (((xPos + closeGrid) * dis == chessWhite_XPOS[chessToCompareIndex])
                            && (yPos * dis == chessWhite_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            // 判断当前下的棋子的左边4个棋子是否都为白棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
                    if (((xPos - closeGrid) * dis == chessWhite_XPOS[chessToCompareIndex])
                            && (yPos * dis == chessWhite_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            chessLinkedCount = 1;
            chessLinkedCompare = 1;
            // 判断当前下的棋子的上边4个棋子是否都为白棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
                    if ((xPos * dis == chessWhite_XPOS[chessToCompareIndex])
                            && ((yPos + closeGrid) * dis == chessWhite_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            // 判断当前下的棋子的下边4个棋子是否都为白棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
                    if ((xPos * dis == chessWhite_XPOS[chessToCompareIndex])
                            && ((yPos - closeGrid) * dis == chessWhite_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            chessLinkedCount = 1;
            chessLinkedCompare = 1;
            // 判断当前下的棋子的左上方向4个棋子是否都为白棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
                    if (((xPos - closeGrid) * dis == chessWhite_XPOS[chessToCompareIndex])
                            && ((yPos + closeGrid) * dis == chessWhite_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            // 判断当前下的棋子的右下方向4个棋子是否都为白棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
                    if (((xPos + closeGrid) * dis == chessWhite_XPOS[chessToCompareIndex])
                            && ((yPos - closeGrid) * dis == chessWhite_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            chessLinkedCount = 1;
            chessLinkedCompare = 1;
            // 判断当前下的棋子的右上方向4个棋子是否都为白棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
                    if (((xPos + closeGrid) * dis == chessWhite_XPOS[chessToCompareIndex])
                            && ((yPos + closeGrid) * dis == chessWhite_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            // 判断当前下的棋子的左下方向4个棋子是否都为白棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
                    if (((xPos - closeGrid) * dis == chessWhite_XPOS[chessToCompareIndex])
                            && ((yPos - closeGrid) * dis == chessWhite_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return (true);
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }
        }
        return false;
    }

    /**
     * 画棋盘
     */
    @Override
    public void paint(Graphics g) {
        for (int i = 40; i <= 580; i = i + 30) {
            g.drawLine(40, i, 580, i);
        }


        for (int j = 40; j <= 580; j = j + 30) {
            g.drawLine(j, 40, j, 580);
        }
        g.fillOval(127, 127, 8, 8);
        g.fillOval(487, 127, 8, 8);
        g.fillOval(127, 487, 8, 8);
        g.fillOval(487, 487, 8, 8);
        g.fillOval(307, 307, 8, 8);
    }

    /**
     * 画棋子 
     * @param xPos
     * @param yPos
     * @param chessColor
     */
    public void paintChessPoint(int xPos, int yPos, int chessColor) {
        ChessBlack chessBlack = new ChessBlack(this);
        ChessWhite chessWhite = new ChessWhite(this);
        // 黑棋
        if (chessColor == 1 && isMouseEnabled) {
            // 设置棋子的位置 
            setLocation(xPos, yPos, chessColor);
            // 取得当前局面状态 
            isWon = checkVicStatus(xPos, yPos, chessColor);
            // 非胜利状态
            if (isWon == false) {
                chessThread.sendMessage("/" + chessPeerName + " /chess "
                        + xPos + " " + yPos + " " + chessColor);
                // 将棋子添加到棋盘中
                this.add(chessBlack);
                // 设置棋子边界 
                chessBlack.setBounds(xPos * dis -4, yPos * dis -3, 30, 30);
                statusText.setText("黑(第" + chessBlackCount + "步)" + xPos + " " + yPos + ",轮到白方.");
                // 将鼠标设为不可用 
                isMouseEnabled = false;
                // 胜利状态
            } else {
                chessThread.sendMessage("/" + chessPeerName + " /chess "
                        + xPos + " " + yPos + " " + chessColor);
                this.add(chessBlack);
                chessBlack.setBounds(xPos * dis -4, yPos * dis -3, 30, 30);
                // 调用胜利方法，传入参数为黑棋胜利
                setVicStatus(1);
                isMouseEnabled = false;
            }
            // 白棋 
        } else if (chessColor == -1 && isMouseEnabled) {
            setLocation(xPos, yPos, chessColor);
            isWon = checkVicStatus(xPos, yPos, chessColor);
            if (isWon == false) {
                chessThread.sendMessage("/" + chessPeerName + " /chess "
                        + xPos + " " + yPos + " " + chessColor);
                this.add(chessWhite);
                chessWhite.setBounds(xPos * dis -4, yPos * dis-3 , 30, 30);
                statusText.setText("白(第" + chessWhiteCount + "步)" + xPos + " " + yPos + ",轮到黑方.");
                isMouseEnabled = false;
            } else {
                chessThread.sendMessage("/" + chessPeerName + " /chess "
                        + xPos + " " + yPos + " " + chessColor);
                this.add(chessWhite);
                chessWhite.setBounds(xPos * dis-4 , yPos * dis -3, 30, 30);
                // 调用胜利方法，传入参数为白棋 
                setVicStatus(-1);
                isMouseEnabled = false;
            }
        }
    }

    /**
     * 画网络棋盘
     * @param xPos
     * @param yPos
     * @param chessColor
     */
    public void paintNetChessPoint(int xPos, int yPos, int chessColor) {
        ChessBlack chessBlack = new ChessBlack(this);
        ChessWhite chessWhite = new ChessWhite(this);
        setLocation(xPos, yPos, chessColor);
        if (chessColor == 1) {
            isWon = checkVicStatus(xPos, yPos, chessColor);
            if (isWon == false) {
                this.add(chessBlack);
                chessBlack.setBounds(xPos * dis-4 , yPos * dis -3, 30, 30);
                statusText.setText("黑(第" + chessBlackCount + "步)" + xPos + " " + yPos + ",轮到白方.");
                isMouseEnabled = true;
            } else {
                chessThread.sendMessage("/" + chessPeerName + " /victory " + chessColor);
                this.add(chessBlack);
                chessBlack.setBounds(xPos * dis -4, yPos * dis-3, 30, 30);
                setVicStatus(1);
                isMouseEnabled = true;
            }
        } else if (chessColor == -1) {
            isWon = checkVicStatus(xPos, yPos, chessColor);
            if (isWon == false) {
                this.add(chessWhite);
                chessWhite.setBounds(xPos * dis-4, yPos * dis-3, 30, 30);
                statusText.setText("白(第" + chessWhiteCount + "步)" + xPos + " " + yPos + ",轮到黑方.");
                isMouseEnabled = true;
            } else {
                chessThread.sendMessage("/" + chessPeerName + " /victory " + chessColor);
                this.add(chessWhite);
                chessWhite.setBounds(xPos * dis-4, yPos * dis-3, 30, 30);
                setVicStatus(-1);
                isMouseEnabled = true;
            }
        }
    }

    /**
     * 捕获下棋事件
     * @param e
     */
    @Override
    public void mousePressed(MouseEvent e) {
        if (e.getModifiers() == InputEvent.BUTTON1_MASK) {
            chessX_POS = e.getX();
            System.out.println(chessX_POS);
            chessY_POS = e.getY();
            System.out.println(chessY_POS);
            int a = (chessX_POS) / dis, b = (chessY_POS) / dis;
            System.out.println("a="+a);
            System.out.println("b="+b);
            // 下棋位置不正确时，不执行任何操作 
            if (chessX_POS / dis < 2 || chessY_POS / dis < 2
                    || chessX_POS / dis > 19 || chessY_POS / dis > 19) {
            } else {
                // 画棋子
                paintChessPoint(a, b, chessColor);
            }
        }
    }
    
    @Override
    public void actionPerformed(ActionEvent e) {}

    @Override
    public void mouseClicked(MouseEvent e) {}

    @Override
    public void mouseReleased(MouseEvent e) {}

    @Override
    public void mouseEntered(MouseEvent e) {}

    @Override
    public void mouseExited(MouseEvent e) {}
}

总结

通过此次的《五子棋》游戏实现，让我对swing的相关知识有了进一步的了解，对java这门语言也有了比以前更深刻的认识。

java的一些基本语法，比如数据类型、运算符、程序流程控制和数组等，理解更加透彻。java最核心的核心就是面向对象思想，对于这一个概念，终于悟到了一些。

以上就是Java+Swing实现经典五子棋游戏的详细内容，更多关于Java Swing五子棋的资料请关注脚本之家其它相关文章！