Java实现五子棋网络版

本文实例为大家分享了Java实现五子棋网络版的具体代码，供大家参考，具体内容如下

需求分析：

对于网络五子棋而言，在普通五子棋的基础上需要添加以下功能：

1.拥有服务器端和客户端，用户通过客户端登录服务器后可与其他登录的用户进行对弈

2.服务器支持多组用户同时进行对弈

3.用户可以在服务器上创建新游戏或加入已创建的游戏

4.用户在下棋的时候可以进行聊天交流

由上可以知道需要实现的功能：

·提供服务器和客户端的功能

·服务器将监听客户端的登录情况并允许多个客户端进行登录

·用户通过客户端可以登录服务器，之后可以看到服务器当前在线的其他用户，并与他们进行聊天等

·用户登录服务器后，可以创建新的五子棋游戏或加入已创建的五子棋游戏

·用户通过客户端可以像普通五子棋那样与其他用户对弈

根据功能将网络五子棋分为4个模块：即用户面板模块、棋盘面板模块、五子棋服务器模块、五子棋客户端模块

下面我们开始进行编译用户面板模块：

1.开发用户列表面板

import java.awt.*; 

/**
 * Created by Administrator on 2016/11/21.
 */
//初始状态下将添加10个名称为“无用户“的信息到列表中，说明服务器最多支持10个用户同时在线
//该列表被添加到面板中，使用“BorderLayout”布局格式
public class UserListPad extends Panel{
  public List userList=new List(10); 

  public UserListPad(){
    setLayout(new BorderLayout());
    for(int i=0;i<10;i++){
      userList.add(i+"."+"无用户");
    }
    add(userList,BorderLayout.CENTER);
  }
}

2.开发用户聊天面板

import javax.swing.*;
import java.awt.*; 

/**
 * Created by Administrator on 2016/11/21.
 */
//聊天面板为一个TextArea视图控件，拥有一个垂直方向的滚动条。
//该TextArea被添加到面板中，使用“BorderLayout”布局格式。
public class UserChatPad extends JPanel{
  public JTextArea chatTextArea=new JTextArea("命令区域",18,20);
  public UserChatPad(){
    setLayout(new BorderLayout());
    chatTextArea.setAutoscrolls(true);
    chatTextArea.setLineWrap(true);
    add(chatTextArea,BorderLayout.CENTER);
  }
}

3.开发用户输入面板

import javax.swing.*;
import java.awt.*; 

/**
 * Created by Administrator on 2016/11/21.
 */
//面板包含两个视图控件
//contentInpitted为TextField控件，用户可以在其中输入聊天信息
public class UserInputPad extends JPanel{
  public JTextField contentInputted = new JTextField("",26);
  public JComboBox userChoice = new JComboBox(); 

  public UserInputPad(){
    setLayout(new FlowLayout(FlowLayout.LEFT));
    for(int i=0;i<50;i++){
      userChoice.addItem(i+"."+"无用户");
    }
    userChoice.setSize(60,24);
    add(userChoice);
    add(contentInputted);
  }
}

4.开发用户操作面板

import javax.swing.*;
import java.awt.*; 

/**
 * Created by Administrator on 2016/11/21.
 */
public class UserControlPad extends JPanel {
  public JLabel ipLabel = new JLabel("IP",JLabel.LEFT);
  public JTextField ipInputted = new JTextField("localhost",10);
  public JButton connectButton = new JButton("连接到服务器");
  public JButton createButton = new JButton("创建游戏");
  public JButton joinButton = new JButton("加入游戏");
  public JButton cancelButton = new JButton("放弃游戏");
  public JButton exitButton = new JButton("退出游戏");
  public UserControlPad(){
    setLayout(new FlowLayout(FlowLayout.LEFT));
    setBackground(Color.LIGHT_GRAY);
    add(ipLabel);
    add(ipInputted);
    add(connectButton);
    add(createButton);
    add(joinButton);
    add(cancelButton);
    add(exitButton);
  }
}

下面开始开发棋盘面板模块

1.开发黑棋类

import java.awt.*; 

/**
 * Created by Administrator on 2016/11/21.
 */
public class FIRPointBlack extends Canvas {
  FIRPad padBelonged; // 黑棋所属的棋盘 

  public FIRPointBlack(FIRPad padBelonged)
  {
    setSize(20, 20); // 设置棋子大小
    this.padBelonged = padBelonged;
  } 

  public void paint(Graphics g)
  { // 画棋子
    g.setColor(Color.black);
    g.fillOval(0, 0, 14, 14);
  }
}

2.开发白棋类

import java.awt.*; 

/**
 * Created by Administrator on 2016/11/21.
 */
public class FIRPointWhite extends Canvas{
  FIRPad padBelonged; // 白棋所属的棋盘 

  public FIRPointWhite(FIRPad padBelonged)
  {
    setSize(20, 20);
    this.padBelonged = padBelonged;
  } 

  public void paint(Graphics g)
  { // 画棋子
    g.setColor(Color.white);
    g.fillOval(0, 0, 14, 14);
  }
}

3.开发棋盘面板

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*; 

import javax.swing.JTextField; 

/**
 * Created by Administrator on 2016/11/21.
 */
public class FIRPad extends Panel implements MouseListener,ActionListener{
  // 鼠标是否能使用
  public boolean isMouseEnabled = false;
  // 是否胜利
  public boolean isWinned = false;
  // 是否在下棋中
  public boolean isGaming = 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;
  public DataInputStream inputData;
  public DataOutputStream outputData;
  public String chessSelfName = null;
  public String chessPeerName = null;
  public String host = null;
  public int port = 4331;
  public TextField statusText = new TextField("请连接服务器！");
  public FIRThread firThread = new FIRThread(this); 

  public FIRPad()
  {
    setSize(440, 440);
    setLayout(null);
    setBackground(Color.LIGHT_GRAY);
    addMouseListener(this);
    add(statusText);
    statusText.setBounds(new Rectangle(40, 5, 360, 24));
    statusText.setEditable(false);
  } 

  // 连接到主机
  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());
      firThread.start();
      return true;
    }
    catch (IOException ex)
    {
      statusText.setText("连接失败! \n");
    }
    return false;
  } 

  // 设定胜利时的棋盘状态
  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, 360, 24);
    if (vicChessColor == 1)
    { // 黑棋胜
      chessBlackVicTimes++;
      statusText.setText("黑方胜,黑:白 " + chessBlackVicTimes + ":" + chessWhiteVicTimes
          + ",游戏重启,等待白方...");
    }
    else if (vicChessColor == -1)
    { // 白棋胜
      chessWhiteVicTimes++;
      statusText.setText("白方胜,黑:白 " + chessBlackVicTimes + ":" + chessWhiteVicTimes
          + ",游戏重启,等待黑方...");
    }
  } 

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

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

  // 画棋盘
  public void paint(Graphics g)
  {
    for (int i = 40; i <= 380; i = i + 20)
    {
      g.drawLine(40, i, 400, i);
    }
    g.drawLine(40, 400, 400, 400);
    for (int j = 40; j <= 380; j = j + 20)
    {
      g.drawLine(j, 40, j, 400);
    }
    g.drawLine(400, 40, 400, 400);
    g.fillOval(97, 97, 6, 6);
    g.fillOval(337, 97, 6, 6);
    g.fillOval(97, 337, 6, 6);
    g.fillOval(337, 337, 6, 6);
    g.fillOval(217, 217, 6, 6);
  } 

  // 画棋子
  public void paintFirPoint(int xPos, int yPos, int chessColor)
  {
    FIRPointBlack firPBlack = new FIRPointBlack(this);
    FIRPointWhite firPWhite = new FIRPointWhite(this);
    if (chessColor == 1 && isMouseEnabled)
    { // 黑棋
      // 设置棋子的位置
      setLocation(xPos, yPos, chessColor);
      // 取得当前局面状态
      isWinned = checkVicStatus(xPos, yPos, chessColor);
      if (isWinned == false)
      { // 非胜利状态
        firThread.sendMessage("/" + chessPeerName + " /chess "
            + xPos + " " + yPos + " " + chessColor);
        this.add(firPBlack); // 将棋子添加到棋盘中
        firPBlack.setBounds(xPos * 20 - 7,
            yPos * 20 - 7, 16, 16); // 设置棋子边界
        statusText.setText("黑(第" + chessBlackCount + "步)"
            + xPos + " " + yPos + ",轮到白方.");
        isMouseEnabled = false; // 将鼠标设为不可用
      }
      else
      { // 胜利状态
        firThread.sendMessage("/" + chessPeerName + " /chess "
            + xPos + " " + yPos + " " + chessColor);
        this.add(firPBlack);
        firPBlack.setBounds(xPos * 20 - 7,
            yPos * 20 - 7, 16, 16);
        setVicStatus(1); // 调用胜利方法，传入参数为黑棋胜利
        isMouseEnabled = false;
      }
    }
    else if (chessColor == -1 && isMouseEnabled)
    { // 白棋
      setLocation(xPos, yPos, chessColor);
      isWinned = checkVicStatus(xPos, yPos, chessColor);
      if (isWinned == false)
      {
        firThread.sendMessage("/" + chessPeerName + " /chess "
            + xPos + " " + yPos + " " + chessColor);
        this.add(firPWhite);
        firPWhite.setBounds(xPos * 20 - 7,
            yPos * 20 - 7, 16, 16);
        statusText.setText("白(第" + chessWhiteCount + "步)"
            + xPos + " " + yPos + ",轮到黑方.");
        isMouseEnabled = false;
      }
      else
      {
        firThread.sendMessage("/" + chessPeerName + " /chess "
            + xPos + " " + yPos + " " + chessColor);
        this.add(firPWhite);
        firPWhite.setBounds(xPos * 20 - 7,
            yPos * 20 - 7, 16, 16);
        setVicStatus(-1); // 调用胜利方法，传入参数为白棋
        isMouseEnabled = false;
      }
    }
  } 

  // 画网络棋盘
  public void paintNetFirPoint(int xPos, int yPos, int chessColor)
  {
    FIRPointBlack firPBlack = new FIRPointBlack(this);
    FIRPointWhite firPWhite = new FIRPointWhite(this);
    setLocation(xPos, yPos, chessColor);
    if (chessColor == 1)
    {
      isWinned = checkVicStatus(xPos, yPos, chessColor);
      if (isWinned == false)
      {
        this.add(firPBlack);
        firPBlack.setBounds(xPos * 20 - 7,
            yPos * 20 - 7, 16, 16);
        statusText.setText("黑(第" + chessBlackCount + "步)"
            + xPos + " " + yPos + ",轮到白方.");
        isMouseEnabled = true;
      }
      else
      {
        firThread.sendMessage("/" + chessPeerName + " /victory "
            + chessColor);//djr
        this.add(firPBlack);
        firPBlack.setBounds(xPos * 20 - 7,
            yPos * 20 - 7, 16, 16);
        setVicStatus(1);
        isMouseEnabled = true;
      }
    }
    else if (chessColor == -1)
    {
      isWinned = checkVicStatus(xPos, yPos, chessColor);
      if (isWinned == false)
      {
        this.add(firPWhite);
        firPWhite.setBounds(xPos * 20 - 7,
            yPos * 20 - 7, 16, 16);
        statusText.setText("白(第" + chessWhiteCount + "步)"
            + xPos + " " + yPos + ",轮到黑方.");
        isMouseEnabled = true;
      }
      else
      {
        firThread.sendMessage("/" + chessPeerName + " /victory "
            + chessColor);
        this.add(firPWhite);
        firPWhite.setBounds(xPos * 20 - 7,
            yPos * 20 - 7, 16, 16);
        setVicStatus(-1);
        isMouseEnabled = true;
      }
    }
  } 

  // 捕获下棋事件
  public void mousePressed(MouseEvent e)
  {
    if (e.getModifiers() == InputEvent.BUTTON1_MASK)
    {
      chessX_POS = (int) e.getX();
      chessY_POS = (int) e.getY();
      int a = (chessX_POS + 10) / 20, b = (chessY_POS + 10) / 20;
      if (chessX_POS / 20 < 2 || chessY_POS / 20 < 2
          || chessX_POS / 20 > 19 || chessY_POS / 20 > 19)
      {
        // 下棋位置不正确时，不执行任何操作
      }
      else
      {
        paintFirPoint(a, b, chessColor); // 画棋子
      }
    }
  } 

  public void mouseReleased(MouseEvent e){}
  public void mouseEntered(MouseEvent e){}
  public void mouseExited(MouseEvent e){}
  public void mouseClicked(MouseEvent e){}
  public void actionPerformed(ActionEvent e){}
}

4.开发棋盘线程

import java.util.StringTokenizer;
import java.io.IOException; 

/**
 * Created by Administrator on 2016/11/21.
 */
public class FIRThread extends Thread{
  FIRPad currPad; // 当前线程的棋盘 

  public FIRThread(FIRPad currPad)
  {
    this.currPad = currPad;
  } 

  // 处理取得的信息
  public void dealWithMsg(String msgReceived)
  {
    if (msgReceived.startsWith("/chess "))
    { // 收到的信息为下棋
      StringTokenizer userMsgToken = new StringTokenizer(msgReceived, " ");
      // 表示棋子信息的数组、0索引为：x坐标；1索引位：y坐标；2索引位：棋子颜色
      String[] chessInfo = { "-1", "-1", "0" };
      int i = 0; // 标志位
      String chessInfoToken;
      while (userMsgToken.hasMoreTokens())
      {
        chessInfoToken = (String) userMsgToken.nextToken(" ");
        if (i >= 1 && i <= 3)
        {
          chessInfo[i - 1] = chessInfoToken;
        }
        i++;
      }
      currPad.paintNetFirPoint(Integer.parseInt(chessInfo[0]), Integer
          .parseInt(chessInfo[1]), Integer.parseInt(chessInfo[2]));
    }
    else if (msgReceived.startsWith("/yourname "))
    { // 收到的信息为改名
      currPad.chessSelfName = msgReceived.substring(10);
    }
    else if (msgReceived.equals("/error"))
    { // 收到的为错误信息
      currPad.statusText.setText("用户不存在，请重新加入!");
    }
  } 

  // 发送信息
  public void sendMessage(String sndMessage)
  {
    try
    {
      currPad.outputData.writeUTF(sndMessage);
    }
    catch (Exception ea)
    {
      ea.printStackTrace();;
    }
  } 

  public void run()
  {
    String msgReceived = "";
    try
    {
      while (true)
      { // 等待信息输入
        msgReceived = currPad.inputData.readUTF();
        dealWithMsg(msgReceived);
      }
    }
    catch (IOException es){}
  }
}

下面开始开发服务器模块

1.开发服务器信息面板

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Label;
import java.awt.Panel;
import java.awt.TextArea; 

import javax.swing.JLabel; 

/**
 * Created by Administrator on 2016/11/21.
 */
public class ServerMsgPanel extends Panel {
  public TextArea msgTextArea = new TextArea("", 22, 50,
      TextArea.SCROLLBARS_VERTICAL_ONLY);
  public JLabel statusLabel = new JLabel("当前连接数:", Label.LEFT);
  public Panel msgPanel = new Panel();
  public Panel statusPanel = new Panel();
  public ServerMsgPanel()
  {
    setSize(350, 300);
    setBackground(Color.LIGHT_GRAY);
    setLayout(new BorderLayout());
    msgPanel.setLayout(new FlowLayout());
    msgPanel.setSize(210, 210);
    statusPanel.setLayout(new BorderLayout());
    statusPanel.setSize(210, 50);
    msgPanel.add(msgTextArea);
    statusPanel.add(statusLabel, BorderLayout.WEST);
    add(msgPanel, BorderLayout.CENTER);
    add(statusPanel, BorderLayout.NORTH);
  } 

}

2.开发服务器进程

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.StringTokenizer; 

/**
 * Created by Administrator on 2016/11/21.
 */
public class FIRServerThread extends Thread{
  Socket clientSocket; // 保存客户端套接口信息
  Hashtable clientDataHash; // 保存客户端端口与输出流对应的Hash
  Hashtable clientNameHash; // 保存客户端套接口和客户名对应的Hash
  Hashtable chessPeerHash; // 保存游戏创建者和游戏加入者对应的Hash
  ServerMsgPanel serverMsgPanel;
  boolean isClientClosed = false; 

  public FIRServerThread(Socket clientSocket, Hashtable clientDataHash,
              Hashtable clientNameHash, Hashtable chessPeerHash,
              ServerMsgPanel server)
  {
    this.clientSocket = clientSocket;
    this.clientDataHash = clientDataHash;
    this.clientNameHash = clientNameHash;
    this.chessPeerHash = chessPeerHash;
    this.serverMsgPanel = server;
  } 

  public void dealWithMsg(String msgReceived)
  {
    String clientName;
    String peerName;
    if (msgReceived.startsWith("/"))
    {
      if (msgReceived.equals("/list"))
      { // 收到的信息为更新用户列表
        Feedback(getUserList());
      }
      else if (msgReceived.startsWith("/creatgame [inchess]"))
      { // 收到的信息为创建游戏
        String gameCreaterName = msgReceived.substring(20); //取得服务器名
        synchronized (clientNameHash)
        { // 将用户端口放到用户列表中
          clientNameHash.put(clientSocket, msgReceived.substring(11));
        }
        synchronized (chessPeerHash)
        { // 将主机设置为等待状态
          chessPeerHash.put(gameCreaterName, "wait");
        }
        Feedback("/yourname " + clientNameHash.get(clientSocket));
        sendGamePeerMsg(gameCreaterName, "/OK");
        sendPublicMsg(getUserList());
      }
      else if (msgReceived.startsWith("/joingame "))
      { // 收到的信息为加入游戏时
        StringTokenizer userTokens = new StringTokenizer(msgReceived, " ");
        String userToken;
        String gameCreatorName;
        String gamePaticipantName;
        String[] playerNames = { "0", "0" };
        int nameIndex = 0;
        while (userTokens.hasMoreTokens())
        {
          userToken = (String) userTokens.nextToken(" ");
          if (nameIndex >= 1 && nameIndex <= 2)
          {
            playerNames[nameIndex - 1] = userToken; // 取得游戏者命
          }
          nameIndex++;
        }
        gameCreatorName = playerNames[0];
        gamePaticipantName = playerNames[1];
        if (chessPeerHash.containsKey(gameCreatorName)
            && chessPeerHash.get(gameCreatorName).equals("wait"))
        { // 游戏已创建
          synchronized (clientNameHash)
          { // 增加游戏加入者的套接口与名称的对应
            clientNameHash.put(clientSocket,
                ("[inchess]" + gamePaticipantName));
          }
          synchronized (chessPeerHash)
          { // 增加或修改游戏创建者与游戏加入者的名称的对应
            chessPeerHash.put(gameCreatorName, gamePaticipantName);
          }
          sendPublicMsg(getUserList());
          // 发送信息给游戏加入者
          sendGamePeerMsg(gamePaticipantName,
              ("/peer " + "[inchess]" + gameCreatorName));
          // 发送游戏给游戏创建者
          sendGamePeerMsg(gameCreatorName,
              ("/peer " + "[inchess]" + gamePaticipantName));
        }
        else
        { // 若游戏未创建则拒绝加入游戏
          sendGamePeerMsg(gamePaticipantName, "/reject");
          try
          {
            closeClient();
          }
          catch (Exception ez)
          {
            ez.printStackTrace();
          }
        }
      }
      else if (msgReceived.startsWith("/[inchess]"))
      { // 收到的信息为游戏中时
        int firstLocation = 0, lastLocation;
        lastLocation = msgReceived.indexOf(" ", 0);
        peerName = msgReceived.substring((firstLocation + 1), lastLocation);
        msgReceived = msgReceived.substring((lastLocation + 1));
        if (sendGamePeerMsg(peerName, msgReceived))
        {
          Feedback("/error");
        }
      }
      else if (msgReceived.startsWith("/giveup "))
      { // 收到的信息为放弃游戏时
        String chessClientName = msgReceived.substring(8);
        if (chessPeerHash.containsKey(chessClientName)
            && !((String) chessPeerHash.get(chessClientName))
            .equals("wait"))
        { // 胜利方为游戏加入者，发送胜利信息
          sendGamePeerMsg((String) chessPeerHash.get(chessClientName),
              "/youwin");
          synchronized (chessPeerHash)
          { // 删除退出游戏的用户
            chessPeerHash.remove(chessClientName);
          }
        }
        if (chessPeerHash.containsValue(chessClientName))
        { // 胜利方为游戏创建者，发送胜利信息
          sendGamePeerMsg((String) getHashKey(chessPeerHash,
              chessClientName), "/youwin");
          synchronized (chessPeerHash)
          {// 删除退出游戏的用户
            chessPeerHash.remove((String) getHashKey(chessPeerHash,
                chessClientName));
          }
        }
      }
      else
      { // 收到的信息为其它信息时
        int lastLocation = msgReceived.indexOf(" ", 0);
        if (lastLocation == -1)
        {
          Feedback("无效命令");
          return;
        }
      }
    }
    else
    {
      msgReceived = clientNameHash.get(clientSocket) + ">" + msgReceived;
      serverMsgPanel.msgTextArea.append(msgReceived + "\n");
      sendPublicMsg(msgReceived);
      serverMsgPanel.msgTextArea.setCaretPosition(serverMsgPanel.msgTextArea.getText()
          .length());
    }
  } 

  // 发送公开信息
  public void sendPublicMsg(String publicMsg)
  {
    synchronized (clientDataHash)
    {
      for (Enumeration enu = clientDataHash.elements(); enu
          .hasMoreElements();)
      {
        DataOutputStream outputData = (DataOutputStream) enu.nextElement();
        try
        {
          outputData.writeUTF(publicMsg);
        }
        catch (IOException es)
        {
          es.printStackTrace();
        }
      }
    }
  } 

  // 发送信息给指定的游戏中的用户
  public boolean sendGamePeerMsg(String gamePeerTarget, String gamePeerMsg)
  {
    for (Enumeration enu = clientDataHash.keys(); enu.hasMoreElements();)
    { // 遍历以取得游戏中的用户的套接口
      Socket userClient = (Socket) enu.nextElement();
      if (gamePeerTarget.equals((String) clientNameHash.get(userClient))
          && !gamePeerTarget.equals((String) clientNameHash
          .get(clientSocket)))
      { // 找到要发送信息的用户时
        synchronized (clientDataHash)
        {
          // 建立输出流
          DataOutputStream peerOutData = (DataOutputStream) clientDataHash
              .get(userClient);
          try
          {
            // 发送信息
            peerOutData.writeUTF(gamePeerMsg);
          }
          catch (IOException es)
          {
            es.printStackTrace();
          }
        }
        return false;
      }
    }
    return true;
  } 

  // 发送反馈信息给连接到主机的人
  public void Feedback(String feedBackMsg)
  {
    synchronized (clientDataHash)
    {
      DataOutputStream outputData = (DataOutputStream) clientDataHash
          .get(clientSocket);
      try
      {
        outputData.writeUTF(feedBackMsg);
      }
      catch (Exception eb)
      {
        eb.printStackTrace();
      }
    }
  } 

  // 取得用户列表
  public String getUserList()
  {
    String userList = "/userlist";
    for (Enumeration enu = clientNameHash.elements(); enu.hasMoreElements();)
    {
      userList = userList + " " + (String) enu.nextElement();
    }
    return userList;
  } 

  // 根据value值从Hashtable中取得相应的key
  public Object getHashKey(Hashtable targetHash, Object hashValue)
  {
    Object hashKey;
    for (Enumeration enu = targetHash.keys(); enu.hasMoreElements();)
    {
      hashKey = (Object) enu.nextElement();
      if (hashValue.equals((Object) targetHash.get(hashKey)))
        return hashKey;
    }
    return null;
  } 

  // 刚连接到主机时执行的方法
  public void sendInitMsg()
  {
    sendPublicMsg(getUserList());
    Feedback("/yourname " + (String) clientNameHash.get(clientSocket));
    Feedback("Java 五子棋客户端");
    Feedback("/list --更新用户列表");
    Feedback("/<username> <talk> --私聊");
    Feedback("注意：命令必须对所有用户发送");
  } 

  public void closeClient()
  {
    serverMsgPanel.msgTextArea.append("用户断开连接:" + clientSocket + "\n");
    synchronized (chessPeerHash)
    { //如果是游戏客户端主机
      if (chessPeerHash.containsKey(clientNameHash.get(clientSocket)))
      {
        chessPeerHash.remove((String) clientNameHash.get(clientSocket));
      }
      if (chessPeerHash.containsValue(clientNameHash.get(clientSocket)))
      {
        chessPeerHash.put((String) getHashKey(chessPeerHash,
            (String) clientNameHash.get(clientSocket)),
            "tobeclosed");
      }
    }
    synchronized (clientDataHash)
    { // 删除客户数据
      clientDataHash.remove(clientSocket);
    }
    synchronized (clientNameHash)
    { // 删除客户数据
      clientNameHash.remove(clientSocket);
    }
    sendPublicMsg(getUserList());
    serverMsgPanel.statusLabel.setText("当前连接数:" + clientDataHash.size());
    try
    {
      clientSocket.close();
    }
    catch (IOException exx)
    {
      exx.printStackTrace();
    }
    isClientClosed = true;
  } 

  public void run()
  {
    DataInputStream inputData;
    synchronized (clientDataHash)
    {
      serverMsgPanel.statusLabel.setText("当前连接数:" + clientDataHash.size());
    }
    try
    {  // 等待连接到主机的信息
      inputData = new DataInputStream(clientSocket.getInputStream());
      sendInitMsg();
      while (true)
      {
        String message = inputData.readUTF();
        dealWithMsg(message);
      }
    }
    catch (IOException esx){}
    finally
    {
      if (!isClientClosed)
      {
        closeClient();
      }
    }
  }
}

3.开发服务器端

import java.io.*;
import java.net.*;
import java.awt.*;
import java.util.*;
import java.awt.event.*; 

import javax.swing.JButton;
/**
 * Created by Administrator on 2016/11/21.
 */
public class FIRServer 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;
  Hashtable clientDataHash = new Hashtable(50); //将客户端套接口和输出流绑定
  Hashtable clientNameHash = new Hashtable(50); //将客户端套接口和客户名绑定
  Hashtable chessPeerHash = new Hashtable(50); //将游戏创建者和游戏加入者绑定 

  public FIRServer()
  {
    super("Java 五子棋服务器");
    setBackground(Color.LIGHT_GRAY);
    buttonPanel.setLayout(new FlowLayout());
    clearMsgButton.setSize(60, 25);
    buttonPanel.add(clearMsgButton);
    clearMsgButton.addActionListener(this);
    serverStatusButton.setSize(75, 25);
    buttonPanel.add(serverStatusButton);
    serverStatusButton.addActionListener(this);
    closeServerButton.setSize(75, 25);
    buttonPanel.add(closeServerButton);
    closeServerButton.addActionListener(this);
    add(serverMsgPanel, BorderLayout.CENTER);
    add(buttonPanel, BorderLayout.SOUTH); 

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

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

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

  public void actionPerformed(ActionEvent e)
  {
    if (e.getSource() == clearMsgButton)
    { // 清空服务器信息
      serverMsgPanel.msgTextArea.setText("");
    }
    if (e.getSource() == serverStatusButton)
    { // 显示服务器信息
      try
      {
        serverMsgPanel.msgTextArea.append("服务器信息:"
            + InetAddress.getLocalHost() + ":"
            + serverSocket.getLocalPort() + "\n");
      }
      catch (Exception ee)
      {
        ee.printStackTrace();
      }
    }
    if (e.getSource() == closeServerButton)
    { // 关闭服务器
      System.exit(0);
    }
  } 

  public static void main(String args[])
  {
    FIRServer firServer = new FIRServer();
  }
}

下面开始编写客户端模块

1.开发客户端

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*; 

import javax.swing.JFrame; 

import djr.chess.gui.UserChatPad;
import djr.chess.gui.UserControlPad;
import djr.chess.gui.UserInputPad;
import djr.chess.gui.UserListPad;
import djr.chess.pad.FIRPad; 

/**
 * Created by Administrator on 2016/11/21.
 */
public class FIRClient extends Frame implements ActionListener,KeyListener {
  // 客户端套接口
  Socket clientSocket;
  // 数据输入流
  DataInputStream inputStream;
  // 数据输出流
  DataOutputStream outputStream;
  // 用户名
  String chessClientName = null;
  // 主机地址
  String host = null;
  // 主机端口
  int port = 4331;
  // 是否在聊天
  boolean isOnChat = false;
  // 是否在下棋
  boolean isOnChess = false;
  // 游戏是否进行中
  boolean isGameConnected = false;
  // 是否为游戏创建者
  boolean isCreator = false;
  // 是否为游戏加入者
  boolean isParticipant = false;
  // 用户列表区
  UserListPad userListPad = new UserListPad();
  // 用户聊天区
  UserChatPad userChatPad = new UserChatPad();
  // 用户操作区
  UserControlPad userControlPad = new UserControlPad();
  // 用户输入区
  UserInputPad userInputPad = new UserInputPad();
  // 下棋区
  FIRPad firPad = new FIRPad();
  // 面板区
  Panel southPanel = new Panel();
  Panel northPanel = new Panel();
  Panel centerPanel = new Panel();
  Panel eastPanel = new Panel(); 

  // 构造方法，创建界面
  public FIRClient()
  {
    super("Java 五子棋客户端");
    setLayout(new BorderLayout());
    host = userControlPad.ipInputted.getText(); 

    eastPanel.setLayout(new BorderLayout());
    eastPanel.add(userListPad, BorderLayout.NORTH);
    eastPanel.add(userChatPad, BorderLayout.CENTER);
    eastPanel.setBackground(Color.LIGHT_GRAY); 

    userInputPad.contentInputted.addKeyListener(this); 

    firPad.host = userControlPad.ipInputted.getText();
    centerPanel.add(firPad, BorderLayout.CENTER);
    centerPanel.add(userInputPad, BorderLayout.SOUTH);
    centerPanel.setBackground(Color.LIGHT_GRAY);
    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(Color.LIGHT_GRAY); 

    addWindowListener(new WindowAdapter()
    {
      public void windowClosing(WindowEvent e)
      {
        if (isOnChat)
        { // 聊天中
          try
          { // 关闭客户端套接口
            clientSocket.close();
          }
          catch (Exception ed){}
        }
        if (isOnChess || isGameConnected)
        { // 下棋中
          try
          {  // 关闭下棋端口
            firPad.chessSocket.close();
          }
          catch (Exception ee){}
        }
        System.exit(0);
      }
    }); 

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

  // 按指定的IP地址和端口连接到服务器
  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());
      // 创建客户端线程
      FIRClientThread clientthread = new FIRClientThread(this);
      // 启动线程，等待聊天信息
      clientthread.start();
      isOnChat = true;
      return true;
    }
    catch (IOException ex)
    {
      userChatPad.chatTextArea
          .setText("不能连接!\n");
    }
    return false;
  } 

  // 客户端事件处理
  public void actionPerformed(ActionEvent e)
  {
    if (e.getSource() == userControlPad.connectButton)
    { // 连接到主机按钮单击事件
      host = firPad.host = userControlPad.ipInputted.getText(); // 取得主机地址
      try
      {
        if (connectToServer(host, port))
        {  // 成功连接到主机时，设置客户端相应的界面状态
          userChatPad.chatTextArea.setText("");
          userControlPad.connectButton.setEnabled(false);
          userControlPad.createButton.setEnabled(true);
          userControlPad.joinButton.setEnabled(true);
          firPad.statusText.setText("连接成功，请等待!");
        }
      }
      catch (Exception ei)
      {
        userChatPad.chatTextArea
            .setText("不能连接!\n");
      }
    }
    if (e.getSource() == userControlPad.exitButton)
    { // 离开游戏按钮单击事件
      if (isOnChat)
      { // 若用户处于聊天状态中
        try
        { // 关闭客户端套接口
          clientSocket.close();
        }
        catch (Exception ed){}
      }
      if (isOnChess || isGameConnected)
      { // 若用户处于游戏状态中
        try
        { // 关闭游戏端口
          firPad.chessSocket.close();
        }
        catch (Exception ee){}
      }
      System.exit(0);
    }
    if (e.getSource() == userControlPad.joinButton)
    { // 加入游戏按钮单击事件
      String selectedUser = (String)userListPad.userList.getSelectedItem(); // 取得要加入的游戏
      if (selectedUser == null || selectedUser.startsWith("[inchess]") ||
          selectedUser.equals(chessClientName))
      { // 若未选中要加入的用户，或选中的用户已经在游戏，则给出提示信息
        firPad.statusText.setText("必须选择一个用户!");
      }
      else
      { // 执行加入游戏的操作
        try
        {
          if (!isGameConnected)
          { // 若游戏套接口未连接
            if (firPad.connectServer(firPad.host, firPad.port))
            { // 若连接到主机成功
              isGameConnected = true;
              isOnChess = true;
              isParticipant = true;
              userControlPad.createButton.setEnabled(false);
              userControlPad.joinButton.setEnabled(false);
              userControlPad.cancelButton.setEnabled(true);
              firPad.firThread.sendMessage("/joingame "
                  + (String)userListPad.userList.getSelectedItem() + " "
                  + chessClientName);
            }
          }
          else
          { // 若游戏端口连接中
            isOnChess = true;
            isParticipant = true;
            userControlPad.createButton.setEnabled(false);
            userControlPad.joinButton.setEnabled(false);
            userControlPad.cancelButton.setEnabled(true);
            firPad.firThread.sendMessage("/joingame "
                + (String)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 (firPad.connectServer(firPad.host, firPad.port))
          { // 若连接到主机成功
            isGameConnected = true;
            isOnChess = true;
            isCreator = true;
            userControlPad.createButton.setEnabled(false);
            userControlPad.joinButton.setEnabled(false);
            userControlPad.cancelButton.setEnabled(true);
            firPad.firThread.sendMessage("/creatgame "
                + "[inchess]" + chessClientName);
          }
        }
        else
        { // 若游戏端口连接中
          isOnChess = true;
          isCreator = true;
          userControlPad.createButton.setEnabled(false);
          userControlPad.joinButton.setEnabled(false);
          userControlPad.cancelButton.setEnabled(true);
          firPad.firThread.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("不能连接: \n"
            + ec);
      }
    }
    if (e.getSource() == userControlPad.cancelButton)
    { // 退出游戏按钮单击事件
      if (isOnChess)
      { // 游戏中
        firPad.firThread.sendMessage("/giveup " + chessClientName);
        firPad.setVicStatus(-1 * firPad.chessColor);
        userControlPad.createButton.setEnabled(true);
        userControlPad.joinButton.setEnabled(true);
        userControlPad.cancelButton.setEnabled(false);
        firPad.statusText.setText("请创建或加入游戏!");
      }
      if (!isOnChess)
      { // 非游戏中
        userControlPad.createButton.setEnabled(true);
        userControlPad.joinButton.setEnabled(true);
        userControlPad.cancelButton.setEnabled(false);
        firPad.statusText.setText("请创建或加入游戏!");
      }
      isParticipant = isCreator = false;
    }
  } 

  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("不能连接到服务器!\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("不能连接到服务器!\n");
          userListPad.userList.removeAll();
          userInputPad.userChoice.removeAll();
          inputwords.setText("");
          userControlPad.connectButton.setEnabled(true);
        }
      }
    }
  } 

  public void keyTyped(KeyEvent e) {}
  public void keyReleased(KeyEvent e) {} 

  public static void main(String args[])
  {
    FIRClient chessClient = new FIRClient();
  }
}

2.开发客户端线程

import java.io.IOException;
import java.util.StringTokenizer; 

import javax.swing.DefaultListModel;
import javax.swing.ListModel; 

/**
 * Created by Administrator on 2016/11/21.
 */
public class FIRClientThread extends Thread{
  public FIRClient firClient; 

  public FIRClientThread(FIRClient firClient)
  {
    this.firClient = firClient;
  } 

  public void dealWithMsg(String msgReceived)
  {
    if (msgReceived.startsWith("/userlist "))
    { // 若取得的信息为用户列表
      StringTokenizer userToken = new StringTokenizer(msgReceived, " ");
      int userNumber = 0;
      // 清空客户端用户列表
      firClient.userListPad.userList.removeAll();
      // 清空客户端用户下拉框
      firClient.userInputPad.userChoice.removeAll();
      // 给客户端用户下拉框添加一个选项
      firClient.userInputPad.userChoice.addItem("所有用户");
      while (userToken.hasMoreTokens())
      { // 当收到的用户信息列表中存在数据时
        String user = (String) userToken.nextToken(" "); // 取得用户信息
        if (userNumber > 0 && !user.startsWith("[inchess]"))
        { // 用户信息有效时
          firClient.userListPad.userList.add(user);// 将用户信息添加到用户列表中
          firClient.userInputPad.userChoice.addItem(user); // 将用户信息添加到用户下拉框中
        }
        userNumber++;
      }
      firClient.userInputPad.userChoice.setSelectedIndex(0);// 下拉框默认选中所有人
    }
    else if (msgReceived.startsWith("/yourname "))
    { // 收到的信息为用户本名时
      firClient.chessClientName = msgReceived.substring(10); // 取得用户本名
      firClient.setTitle("Java 五子棋客户端 " + "用户名:"
          + firClient.chessClientName); // 设置程序Frame的标题
    }
    else if (msgReceived.equals("/reject"))
    { // 收到的信息为拒绝用户时
      try
      {
        firClient.firPad.statusText.setText("不能加入游戏!");
        firClient.userControlPad.cancelButton.setEnabled(false);
        firClient.userControlPad.joinButton.setEnabled(true);
        firClient.userControlPad.createButton.setEnabled(true);
      }
      catch (Exception ef)
      {
        firClient.userChatPad.chatTextArea
            .setText("Cannot close!");
      }
      firClient.userControlPad.joinButton.setEnabled(true);
    }
    else if (msgReceived.startsWith("/peer "))
    { // 收到信息为游戏中的等待时
      firClient.firPad.chessPeerName = msgReceived.substring(6);
      if (firClient.isCreator)
      { // 若用户为游戏建立者
        firClient.firPad.chessColor = 1; // 设定其为黑棋先行
        firClient.firPad.isMouseEnabled = true;
        firClient.firPad.statusText.setText("黑方下...");
      }
      else if (firClient.isParticipant)
      { // 若用户为游戏加入者
        firClient.firPad.chessColor = -1; // 设定其为白棋后性
        firClient.firPad.statusText.setText("游戏加入，等待对手.");
      }
    }
    else if (msgReceived.equals("/youwin"))
    { // 收到信息为胜利信息
      firClient.isOnChess = false;
      firClient.firPad.setVicStatus(firClient.firPad.chessColor);
      firClient.firPad.statusText.setText("对手退出");
      firClient.firPad.isMouseEnabled = false;
    }
    else if (msgReceived.equals("/OK"))
    { // 收到信息为成功创建游戏
      firClient.firPad.statusText.setText("游戏创建等待对手");
    } 

    else if (msgReceived.equals("/error"))
    { // 收到信息错误
      firClient.userChatPad.chatTextArea.append("错误，退出程序.\n");
    }
    else
    {
      firClient.userChatPad.chatTextArea.append(msgReceived + "\n");
      firClient.userChatPad.chatTextArea.setCaretPosition(
          firClient.userChatPad.chatTextArea.getText().length());
    }
  } 

  public void run()
  {
    String message = "";
    try
    {
      while (true)
      {
        // 等待聊天信息，进入wait状态
        message = firClient.inputStream.readUTF();
        dealWithMsg(message);
      }
    }
    catch (IOException es){}
  }
}

至此，网络版五子棋就算是开发完成了。关于这么多类和包的关系如下图：

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。

您可能感兴趣的文章:

• Java五子棋单机版源码分享
• Java实现两人五子棋游戏(七) 屏幕提示信息
• Java实现两人五子棋游戏(六) 行棋方变换
• Java实现两人五子棋游戏(五) 判断是否有一方胜出
• Java实现两人五子棋游戏(四) 落子动作的实现
• Java实现两人五子棋游戏(三) 画出棋子
• Java实现两人五子棋游戏(二) 画出棋盘
• Java实现五子棋AI算法
• Java编程实现五子棋人人对战代码示例
• java实现单机版五子棋