跪求JAVA五子棋源代码

很sb的电脑五子棋：

昭阳ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景，ssl证书未来市场广阔！成为成都创新互联的ssl证书销售渠道，可以享受市场价格4-6折优惠！如果有意向欢迎电话联系或者加微信：18980820575（备注：SSL证书合作）期待与您的合作！

import java.io.*;

import java.util.*;

public class Gobang {

// 定义一个二维数组来充当棋盘

private String[][] board;

// 定义棋盘的大小

private static int BOARD_SIZE = 15;

public void initBoard() {

// 初始化棋盘数组

board = new String[BOARD_SIZE][BOARD_SIZE];

// 把每个元素赋为"╋"，用于在控制台画出棋盘

for (int i = 0; i BOARD_SIZE; i++) {

for (int j = 0; j BOARD_SIZE; j++) {

// windows是一行一行来打印的。坐标值为(行值, 列值)

board[i][j] = "╋";

}

}

}

// 在控制台输出棋盘的方法

public void printBoard() {

// 打印每个数组元素

for (int i = 0; i BOARD_SIZE; i++) {

for (int j = 0; j BOARD_SIZE; j++) {

// 打印数组元素后不换行

System.out.print(board[i][j]);

}

// 每打印完一行数组元素后输出一个换行符

System.out.print("\n");

}

}

// 该方法处理电脑下棋：随机生成2个整数，作为电脑下棋的坐标，赋给board数组。

private void compPlay() {

// 构造一个随机数生成器

Random rnd = new Random();

// Random类的nextInt(int n))方法：随机地生成并返回指定范围中的一个 int 值，

// 即：在此随机数生成器序列中 0（包括）和 n（不包括）之间均匀分布的一个int值。

int compXPos = rnd.nextInt(15);

int compYPos = rnd.nextInt(15);

// 保证电脑下的棋的坐标上不能已经有棋子（通过判断对应数组元素只能是"╋"来确定）

while (board[compXPos][compYPos].equals("╋") == false) {

compXPos = rnd.nextInt(15);

compYPos = rnd.nextInt(15);

}

System.out.println(compXPos);

System.out.println(compYPos);

// 把对应的数组元素赋为"○"。

board[compXPos][compYPos] = "○";

}

// 该方法用于判断胜负：进行四次循环扫描，判断横、竖、左斜、右斜是否有5个棋连在一起

private boolean judgeWin() {

// flag表示是否可以断定赢/输

boolean flag = false;

// joinEle：将每一个横/竖/左斜/右斜行中的元素连接起来得到的一个字符串

String joinEle;

// 进行横行扫描

for (int i = 0; i BOARD_SIZE; i++) {

// 每扫描一行前，将joinEle清空

joinEle = "";

for (int j = 0; j BOARD_SIZE; j++) {

joinEle += board[i][j];

}

// String类的contains方法：当且仅当该字符串包含指定的字符序列时，返回true。

if (joinEle.contains("●●●●●")) {

System.out.println("您赢啦！");

flag = true;

// 停止往下继续执行，提前返回flag。

// 如果执行了这个return，就直接返回该方法的调用处；

// 不会再执行后面的任何语句，包括最后那个return语句。

// （而break仅仅是完全跳出这个for循环，还会继续执行下面的for循环。）

return flag;

} else if (joinEle.contains("○○○○○")) {

System.out.println("您输啦！");

flag = true;

// 提前返回flag

return flag;

}

}

// 进行竖行扫描

for (int i = 0; i BOARD_SIZE; i++) {

joinEle = "";

for (int j = 0; j BOARD_SIZE; j++) {

// 竖行的元素是它们的列值相同

joinEle += board[j][i];

}

if (joinEle.contains("●●●●●")) {

System.out.println("您赢啦！");

flag = true;

return flag;

} else if (joinEle.contains("○○○○○")) {

System.out.println("您输啦！");

flag = true;

return flag;

}

}

// 进行左斜行扫描

for (int i = -(BOARD_SIZE - 2); i BOARD_SIZE - 1; i++) {

joinEle = "";

for (int j = 0; j BOARD_SIZE; j++) {

int line = i + j;

// 只截取坐标值没有越界的点

if (line = 0 line 15) {

joinEle += board[j][line];

}

}

if (joinEle.contains("●●●●●")) {

System.out.println("您赢啦！");

flag = true;

return flag;

} else if (joinEle.contains("○○○○○")) {

System.out.println("您输啦！");

flag = true;

return flag;

}

}

// 进行右斜行扫描

for (int i = 1; i 2 * (BOARD_SIZE - 1); i++) {

joinEle = "";

for (int j = 0; j BOARD_SIZE; j++) {

int line = i - j;

if (line = 0 line 15) {

joinEle += board[j][line];

}

}

if (joinEle.contains("●●●●●")) {

System.out.println("您赢啦！");

flag = true;

return flag;

} else if (joinEle.contains("○○○○○")) {

System.out.println("您输啦！");

flag = true;

// 最后这个return可省略

}

}

// 确保该方法有返回值（如果上面条件都不满足时）

return flag;

}

public static void main(String[] args) throws Exception, IOException {

Gobang gb = new Gobang();

gb.initBoard();

gb.printBoard();

// BufferedReader类：带缓存的读取器————从字符输入流中读取文本，并缓存字符。可用于高效读取字符、数组和行。

// 最好用它来包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和 InputStreamReader）。

// 下面构造一个读取器对象。

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

// 定义输入字符串

String inputStr = null;

// br.readLine()：每当在键盘上输入一行内容按回车，刚输入的内容将被br（读取器对象）读取到。

// BufferedReader类的readLine方法：读取一个文本行。

// 初始状态由于无任何输入，br.readLine()会抛出异常。因而main方法要捕捉异常。

while ((inputStr = br.readLine()) != null) {

// 将用户输入的字符串以逗号（,）作为分隔符，分隔成2个字符串。

// String类的split方法，将会返回一个拆分后的字符串数组。

String[] posStrArr = inputStr.split(",");

// 将2个字符串转换成用户下棋的坐标

int xPos = Integer.parseInt(posStrArr[0]);

int yPos = Integer.parseInt(posStrArr[1]);

// 校验用户下棋坐标的有效性，只能是数字，不能超出棋盘范围

if (xPos 15 || xPos 1 || yPos 15 || yPos 1) {

System.out.println("您下棋的坐标值应在1到15之间，请重新输入！");

continue;

}

// 保证用户下的棋的坐标上不能已经有棋子（通过判断对应数组元素只能是"╋"来确定）

// String类的equals方法：比较字符串和指定对象是否相等。结果返回true或false。

if (gb.board[xPos - 1][yPos - 1].equals("╋")) {

// 把对应的数组元素赋为"●"。

gb.board[xPos - 1][yPos - 1] = "●";

} else {

System.out.println("您下棋的点已有棋子，请重新输入！");

continue;

}

// 电脑下棋

gb.compPlay();

gb.printBoard();

// 每次下棋后，看是否可以断定赢/输了

if (gb.judgeWin() == false) {

System.out.println("请输入您下棋的坐标，应以x,y的格式：");

} else {

// 完全跳出这个while循环，结束下棋

break;

}

}

}

}

用JAVA做五子棋源代码

java网络五子棋

下面的源代码分为4个文件；

chessClient.java:客户端主程序。

chessInterface.java:客户端的界面。

chessPad.java:棋盘的绘制。

chessServer.java:服务器端。

可同时容纳50个人同时在线下棋，聊天。

没有加上详细注释，不过绝对可以运行，j2sdk1.4下通过。

/*********************************************************************************************

1.chessClient.java

**********************************************************************************************/

import java.awt.*;

import java.awt.event.*;

import java.io.*;

import java.net.*;

import java.util.*;

class clientThread extends Thread

{

chessClient chessclient;

clientThread(chessClient chessclient)

{

this.chessclient=chessclient;

}

public void acceptMessage(String recMessage)

{

if(recMessage.startsWith("/userlist "))

{

StringTokenizer userToken=new StringTokenizer(recMessage," ");

int userNumber=0;

chessclient.userpad.userList.removeAll();

chessclient.inputpad.userChoice.removeAll();

chessclient.inputpad.userChoice.addItem("所有人");

while(userToken.hasMoreTokens())

{

String user=(String)userToken.nextToken(" ");

if(userNumber0 !user.startsWith("[inchess]"))

{

chessclient.userpad.userList.add(user);

chessclient.inputpad.userChoice.addItem(user);

}

userNumber++;

}

chessclient.inputpad.userChoice.select("所有人");

}

else if(recMessage.startsWith("/yourname "))

{

chessclient.chessClientName=recMessage.substring(10);

chessclient.setTitle("Java五子棋客户端 "+"用户名:"+chessclient.chessClientName);

}

else if(recMessage.equals("/reject"))

{

try

{

chessclient.chesspad.statusText.setText("不能加入游戏");

chessclient.controlpad.cancelGameButton.setEnabled(false);

chessclient.controlpad.joinGameButton.setEnabled(true);

chessclient.controlpad.creatGameButton.setEnabled(true);

}

catch(Exception ef)

{

chessclient.chatpad.chatLineArea.setText("chessclient.chesspad.chessSocket.close无法关闭");

}

chessclient.controlpad.joinGameButton.setEnabled(true);

}

else if(recMessage.startsWith("/peer "))

{

chessclient.chesspad.chessPeerName=recMessage.substring(6);

if(chessclient.isServer)

{

chessclient.chesspad.chessColor=1;

chessclient.chesspad.isMouseEnabled=true;

chessclient.chesspad.statusText.setText("请黑棋下子");

}

else if(chessclient.isClient)

{

chessclient.chesspad.chessColor=-1;

chessclient.chesspad.statusText.setText("已加入游戏，等待对方下子...");

}

}

else if(recMessage.equals("/youwin"))

{

chessclient.isOnChess=false;

chessclient.chesspad.chessVictory(chessclient.chesspad.chessColor);

chessclient.chesspad.statusText.setText("对方退出，请点放弃游戏退出连接");

chessclient.chesspad.isMouseEnabled=false;

}

else if(recMessage.equals("/OK"))

{

chessclient.chesspad.statusText.setText("创建游戏成功，等待别人加入...");

}

else if(recMessage.equals("/error"))

{

chessclient.chatpad.chatLineArea.append("传输错误：请退出程序，重新加入 \n");

}

else

{

chessclient.chatpad.chatLineArea.append(recMessage+"\n");

chessclient.chatpad.chatLineArea.setCaretPosition(

chessclient.chatpad.chatLineArea.getText().length());

}

}

public void run()

{

String message="";

try

{

while(true)

{

message=chessclient.in.readUTF();

acceptMessage(message);

}

}

catch(IOException es)

{

}

}

}

public class chessClient extends Frame implements ActionListener,KeyListener

{

userPad userpad=new userPad();

chatPad chatpad=new chatPad();

controlPad controlpad=new controlPad();

chessPad chesspad=new chessPad();

inputPad inputpad=new inputPad();

Socket chatSocket;

DataInputStream in;

DataOutputStream out;

String chessClientName=null;

String host=null;

int port=4331;

boolean isOnChat=false; //在聊天？

boolean isOnChess=false; //在下棋？

boolean isGameConnected=false; //下棋的客户端连接？

boolean isServer=false; //如果是下棋的主机

boolean isClient=false; //如果是下棋的客户端

Panel southPanel=new Panel();

Panel northPanel=new Panel();

Panel centerPanel=new Panel();

Panel westPanel=new Panel();

Panel eastPanel=new Panel();

chessClient()

{

super("Java五子棋客户端");

setLayout(new BorderLayout());

host=controlpad.inputIP.getText();

westPanel.setLayout(new BorderLayout());

westPanel.add(userpad,BorderLayout.NORTH);

westPanel.add(chatpad,BorderLayout.CENTER);

westPanel.setBackground(Color.pink);

inputpad.inputWords.addKeyListener(this);

chesspad.host=controlpad.inputIP.getText();

centerPanel.add(chesspad,BorderLayout.CENTER);

centerPanel.add(inputpad,BorderLayout.SOUTH);

centerPanel.setBackground(Color.pink);

controlpad.connectButton.addActionListener(this);

controlpad.creatGameButton.addActionListener(this);

controlpad.joinGameButton.addActionListener(this);

controlpad.cancelGameButton.addActionListener(this);

controlpad.exitGameButton.addActionListener(this);

controlpad.creatGameButton.setEnabled(false);

controlpad.joinGameButton.setEnabled(false);

controlpad.cancelGameButton.setEnabled(false);

southPanel.add(controlpad,BorderLayout.CENTER);

southPanel.setBackground(Color.pink);

addWindowListener(new WindowAdapter()

{

public void windowClosing(WindowEvent e)

{

if(isOnChat)

{

try

{

chatSocket.close();

}

catch(Exception ed)

{

}

}

if(isOnChess || isGameConnected)

{

try

{

chesspad.chessSocket.close();

}

catch(Exception ee)

{

}

}

System.exit(0);

}

public void windowActivated(WindowEvent ea)

{

}

});

add(westPanel,BorderLayout.WEST);

add(centerPanel,BorderLayout.CENTER);

add(southPanel,BorderLayout.SOUTH);

pack();

setSize(670,548);

setVisible(true);

setResizable(false);

validate();

}

public boolean connectServer(String serverIP,int serverPort) throws Exception

{

try

{

chatSocket=new Socket(serverIP,serverPort);

in=new DataInputStream(chatSocket.getInputStream());

out=new DataOutputStream(chatSocket.getOutputStream());

clientThread clientthread=new clientThread(this);

clientthread.start();

isOnChat=true;

return true;

}

catch(IOException ex)

{

chatpad.chatLineArea.setText("chessClient:connectServer:无法连接,建议重新启动程序 \n");

}

return false;

}

public void actionPerformed(ActionEvent e)

{

if(e.getSource()==controlpad.connectButton)

{

host=chesspad.host=controlpad.inputIP.getText();

try

{

if(connectServer(host,port))

{

chatpad.chatLineArea.setText("");

controlpad.connectButton.setEnabled(false);

controlpad.creatGameButton.setEnabled(true);

controlpad.joinGameButton.setEnabled(true);

chesspad.statusText.setText("连接成功，请创建游戏或加入游戏");

}

}

catch(Exception ei)

{

chatpad.chatLineArea.setText("controlpad.connectButton:无法连接,建议重新启动程序 \n");

}

}

if(e.getSource()==controlpad.exitGameButton)

{

if(isOnChat)

{

try

{

chatSocket.close();

}

catch(Exception ed)

{

}

}

if(isOnChess || isGameConnected)

{

try

{

chesspad.chessSocket.close();

}

catch(Exception ee)

{

}

}

System.exit(0);

}

if(e.getSource()==controlpad.joinGameButton)

{

String selectedUser=userpad.userList.getSelectedItem();

if(selectedUser==null || selectedUser.startsWith("[inchess]") ||

selectedUser.equals(chessClientName))

{

chesspad.statusText.setText("必须先选定一个有效用户");

}

else

{

try

{

if(!isGameConnected)

{

if(chesspad.connectServer(chesspad.host,chesspad.port))

{

isGameConnected=true;

isOnChess=true;

isClient=true;

controlpad.creatGameButton.setEnabled(false);

controlpad.joinGameButton.setEnabled(false);

controlpad.cancelGameButton.setEnabled(true);

chesspad.chessthread.sendMessage("/joingame "+userpad.userList.getSelectedItem()+" "+chessClientName);

}

}

else

{

isOnChess=true;

isClient=true;

controlpad.creatGameButton.setEnabled(false);

controlpad.joinGameButton.setEnabled(false);

controlpad.cancelGameButton.setEnabled(true);

chesspad.chessthread.sendMessage("/joingame "+userpad.userList.getSelectedItem()+" "+chessClientName);

}

}

catch(Exception ee)

{

isGameConnected=false;

isOnChess=false;

isClient=false;

controlpad.creatGameButton.setEnabled(true);

controlpad.joinGameButton.setEnabled(true);

controlpad.cancelGameButton.setEnabled(false);

chatpad.chatLineArea.setText("chesspad.connectServer无法连接 \n"+ee);

}

}

}

if(e.getSource()==controlpad.creatGameButton)

{

try

{

if(!isGameConnected)

{

if(chesspad.connectServer(chesspad.host,chesspad.port))

{

isGameConnected=true;

isOnChess=true;

isServer=true;

controlpad.creatGameButton.setEnabled(false);

controlpad.joinGameButton.setEnabled(false);

controlpad.cancelGameButton.setEnabled(true);

chesspad.chessthread.sendMessage("/creatgame "+"[inchess]"+chessClientName);

}

}

else

{

isOnChess=true;

isServer=true;

controlpad.creatGameButton.setEnabled(false);

controlpad.joinGameButton.setEnabled(false);

controlpad.cancelGameButton.setEnabled(true);

chesspad.chessthread.sendMessage("/creatgame "+"[inchess]"+chessClientName);

}

}

catch(Exception ec)

{

isGameConnected=false;

isOnChess=false;

isServer=false;

controlpad.creatGameButton.setEnabled(true);

controlpad.joinGameButton.setEnabled(true);

controlpad.cancelGameButton.setEnabled(false);

ec.printStackTrace();

chatpad.chatLineArea.setText("chesspad.connectServer无法连接 \n"+ec);

}

}

if(e.getSource()==controlpad.cancelGameButton)

{

if(isOnChess)

{

chesspad.chessthread.sendMessage("/giveup "+chessClientName);

chesspad.chessVictory(-1*chesspad.chessColor);

controlpad.creatGameButton.setEnabled(true);

controlpad.joinGameButton.setEnabled(true);

controlpad.cancelGameButton.setEnabled(false);

chesspad.statusText.setText("请建立游戏或者加入游戏");

}

if(!isOnChess)

{

controlpad.creatGameButton.setEnabled(true);

controlpad.joinGameButton.setEnabled(true);

controlpad.cancelGameButton.setEnabled(false);

chesspad.statusText.setText("请建立游戏或者加入游戏");

}

isClient=isServer=false;

}

}

public void keyPressed(KeyEvent e)

{

TextField inputWords=(TextField)e.getSource();

if(e.getKeyCode()==KeyEvent.VK_ENTER)

{

if(inputpad.userChoice.getSelectedItem().equals("所有人"))

{

try

{

out.writeUTF(inputWords.getText());

inputWords.setText("");

}

catch(Exception ea)

{

chatpad.chatLineArea.setText("chessClient:KeyPressed无法连接,建议重新连接 \n");

userpad.userList.removeAll();

inputpad.userChoice.removeAll();

inputWords.setText("");

controlpad.connectButton.setEnabled(true);

}

}

else

{

try

{

out.writeUTF("/"+inputpad.userChoice.getSelectedItem()+" "+inputWords.getText());

inputWords.setText("");

}

catch(Exception ea)

{

chatpad.chatLineArea.setText("chessClient:KeyPressed无法连接,建议重新连接 \n");

userpad.userList.removeAll();

inputpad.userChoice.removeAll();

inputWords.setText("");

controlpad.connectButton.setEnabled(true);

}

}

}

}

public void keyTyped(KeyEvent e)

{

}

public void keyReleased(KeyEvent e)

{

}

public static void main(String args[])

{

chessClient chessClient=new chessClient();

}

}

/******************************************************************************************

下面是：chessInteface.java

******************************************************************************************/

import java.awt.*;

import java.awt.event.*;

import java.io.*;

import java.net.*;

class userPad extends Panel

{

List userList=new List(10);

userPad()

{

setLayout(new BorderLayout());

for(int i=0;i50;i++)

{

userList.add(i+"."+"没有用户");

}

add(userList,BorderLayout.CENTER);

}

}

class chatPad extends Panel

{

TextArea chatLineArea=new TextArea("",18,30,TextArea.SCROLLBARS_VERTICAL_ONLY);

chatPad()

{

setLayout(new BorderLayout());

add(chatLineArea,BorderLayout.CENTER);

}

}

class controlPad extends Panel

{

Label IPlabel=new Label("IP",Label.LEFT);

TextField inputIP=new TextField("localhost",10);

Button connectButton=new Button("连接主机");

Button creatGameButton=new Button("建立游戏");

Button joinGameButton=new Button("加入游戏");

Button cancelGameButton=new Button("放弃游戏");

Button exitGameButton=new Button("关闭程序");

controlPad()

{

setLayout(new FlowLayout(FlowLayout.LEFT));

setBackground(Color.pink);

add(IPlabel);

add(inputIP);

add(connectButton);

add(creatGameButton);

add(joinGameButton);

add(cancelGameButton);

add(exitGameButton);

}

}

class inputPad extends Panel

{

TextField inputWords=new TextField("",40);

Choice userChoice=new Choice();

inputPad()

{

setLayout(new FlowLayout(FlowLayout.LEFT));

for(int i=0;i50;i++)

{

userChoice.addItem(i+"."+"没有用户");

}

userChoice.setSize(60,24);

add(userChoice);

add(inputWords);

}

}

/**********************************************************************************************

下面是：chessPad.java

**********************************************************************************************/

import java.awt.*;

import java.awt.event.*;

import java.io.*;

import java.net.*;

import java.util.*;

class chessThread extends Thread

{

chessPad chesspad;

chessThread(chessPad chesspad)

{

this.chesspad=chesspad;

}

public void sendMessage(String sndMessage)

{

try

{

chesspad.outData.writeUTF(sndMessage);

}

catch(Exception ea)

{

System.out.println("chessThread.sendMessage:"+ea);

}

}

public void acceptMessage(String recMessage)

{

if(recMessage.startsWith("/chess "))

{

StringTokenizer userToken=new StringTokenizer(recMessage," ");

String chessToken;

String[] chessOpt={"-1","-1","0"};

int chessOptNum=0;

while(userToken.hasMoreTokens())

{

chessToken=(String)userToken.nextToken(" ");

if(chessOptNum=1 chessOptNum=3)

{

chessOpt[chessOptNum-1]=chessToken;

}

chessOptNum++;

}

chesspad.netChessPaint(Integer.parseInt(chessOpt[0]),Integer.parseInt(chessOpt[1]),Integer.parseInt(chessOpt[2]));

}

else if(recMessage.startsWith("/yourname "))

{

chesspad.chessSelfName=recMessage.substring(10);

}

else if(recMessage.equals("/error"))

{

chesspad.statusText.setText("错误:没有这个用户，请退出程序，重新加入");

}

else

{

//System.out.println(recMessage);

}

}

public void run()

{

String message="";

try

{

while(true)

{

message=chesspad.inData.readUTF();

acceptMessage(message);

}

}

catch(IOException es)

{

}

}

}

class chessPad extends Panel implements MouseListener,ActionListener

{

int chessPoint_x=-1,chessPoint_y=-1,chessColor=1;

int chessBlack_x[]=new int[200];

int chessBlack_y[]=new int[200];

int chessWhite_x[]=new int[200];

int chessWhite_y[]=new int[200];

int chessBlackCount=0,chessWhiteCount=0;

int chessBlackWin=0,chessWhiteWin=0;

boolean isMouseEnabled=false,isWin=false,isInGame=false;

TextField statusText=new TextField("请先连接服务器");

Socket chessSocket;

DataInputStream inData;

DataOutputStream outData;

String chessSelfName=null;

String chessPeerName=null;

String host=null;

int port=4331;

chessThread chessthread=new chessThread(this);

chessPad()

{

setSize(440,440);

setLayout(null);

setBackground(Color.pink);

addMouseListener(this);

add(statusText);

statusText.setBounds(40,5,360,24);

statusText.setEditable(false);

}

public boolean connectServer(String ServerIP,int ServerPort) throws Exception

{

try

{

chessSocket=new Socket(ServerIP,ServerPort);

inData=new DataInputStream(chessSocket.getInputStream());

outData=new DataOutputStream(chessSocket.getOutputStream());

chessthread.start();

return true;

}

catch(IOException ex)

{

statusText.setText("chessPad:connectServer:无法连接 \n");

}

return false;

}

public void chessVictory(int chessColorWin)

{

this.removeAll();

for(int i=0;i=chessBlackCount;i++)

{

chessBlack_x[i]=0;

chessBlack_y[i]=0;

}

for(int i=0;i=chessWhiteCount;i++)

{

chessWhite_x[i]=0;

chessWhite_y[i]=0;

}

chessBlackCount=0;

chessWhiteCount=0;

add(statusText);

statusText.setBounds(40,5,360,24);

if(chessColorWin==1)

{ chessBlackWin++;

statusText.setText("黑棋胜,黑:白为"+chessBlackWin+":"+chessWhiteWin+",重新开局,等待白棋下子...");

}

else if(chessColorWin==-1)

{

chessWhiteWin++;

statusText.setText("白棋胜,黑:白为"+chessBlackWin+":"+chessWhiteWin+",重新开局,等待黑棋下子...");

}

}

public void getLocation(int a,int b,int color)

{

if(color==1)

{

chessBlack_x[chessBlackCount]=a*20;

chessBlack_y[chessBlackCount]=b*20;

chessBlackCount++;

}

else if(color==-1)

{

chessWhite_x[chessWhiteCount]=a*20;

chessWhite_y[chessWhiteCount]=b*20;

chessWhiteCount++;

}

}

public boolean checkWin(int a,int b,int checkColor)

{

int step=1,chessLink=1,chessLinkTest=1,chessCompare=0;

if(checkColor==1)

{

chessLink=1;

for(step=1;step=4;step++)

{

for(chessCompare=0;chessCompare=chessBlackCount;chessCompare++)

{

if(((a+step)*20==chessBlack_x[chessCompare]) ((b*20)==chessBlack_y[chessCompare]))

{

chessLink=chessLink+1;

if(chessLink==5)

{

return(true);

}

}

}

if(chessLink==(chessLinkTest+1))

chessLinkTest++;

else

break;

}

for(step=1;step=4;step++)

{

for(chessCompare=0;chessCompare=chessBlackCount;chessCompare++)

{

if(((a-step)*20==chessBlack_x[chessCompare]) (b*20==chessBlack_y[chessCompare]))

{

chessLink++;

if(chessLink==5)

{

return(true);

}

}

}

if(chessLink==(chessLinkTest+1))

chessLinkTest++;

else

break;

}

chessLink=1;

chessLinkTest=1;

for(step=1;step=4;step++)

{

for(chessCompare=0;chessCompare=chessBlackCount;chessCompare++)

{

if((a*20==chessBlack_x[chessCompare]) ((b+step)*20==chessBlack_y[chessCompare]))

{

chessLink++;

if(chessLink==5)

{

return(true);

}

}

}

if(chessLink==(chessLinkTest+1))

chessLinkTest++;

else

break;

}

for(step=1;step=4;step++)

{

for(chessCompare=0;chessCompare=chessBlackCount;chessCompare++)

{

if((a*20==chessBlack_x[chessCompare]) ((b-step)*20==chessBlack_y[chessCompare]))

{

chessLink++;

if(chessLink==5)

{

return(true);

}

}

}

if(chessLink==(chessLinkTest+1))

chessLinkTest++;

else

break;

}

chessLink=1;

chessLinkTest=1;

for(step=1;step=4;step++)

{

for(chessCompare=0;chessCompare=chessBlackCount;chessCompare++)

{

if(((a-step)*20==chessBlack_x[chessCompare]) ((b+step)*20==chessBlack_y[chessCompare]))

{

chessLink++;

if(chessLink==5)

{

return(true);

}

}

}

if(chessLink==(chessLinkTest+1))

chessLinkTest++;

else

break;

}

for(step=1;step=4;step++)

{

for(chessCompare=0;chessCompare=chessBlackCount;chessCompare++)

{

if(((a+step)*20==chessBlack_x[chessCompare]) ((b-step)*20==chessBlack_y[chessCompare]))

{

chessLink++;

if(chessLink==5)

{

return(true);

}

}

}

if(chessLink==(chessLinkTest+1))

chessLinkTest++;

else

break;

}

chessLink=1;

chessLinkTest=1;

for(step=1;step=4;step++)

{

for(chessCompare=0;chessCompare=chessBlackCount;chessCompare++)

{

if(((a+step)*20==chessBlack_x[chessCompare]) ((b+step)*20==chessBlack_y[chessCompare]))

{

chessLink++;

if(chessLink==5)

{

return(true);

}

}

}

if(chessLink==(chessLinkTest+1))

chessLinkTest++;

else

break;

}

for(step=1;step=4;step++)

{

for(chessCompare=0;chessCompare=chessBlackCount;chessCompare++)

{

if(((a-step)*20==chessBlack_x[chessCompare]) ((b-step)*20==chessBlack_y[chessCompare]))

{

chessLink++;

if(chessLink==5)

{

return(true);

}

}

求一个简单的JAVA五子棋代码！！ 网上复制的别来了！

以下是现写的 实现了两人对战 自己复制后运行把 没什么难度 类名 Games

import java.util.Scanner;

public class Games {

private String board[][];

private static int SIZE = 17;

private static String roles = "A玩家";

//初始化数组

public void initBoard() {

board = new String[SIZE][SIZE];

for (int i = 0; i SIZE; i++) {

for (int j = 0; j SIZE; j++) {

// if(i==0){

// String str = "";

// str += j+" ";

// board[i][j]= str;

// }else if(i!=0j==0){

// String str = "";

// str += i+" ";

// board[i][j]= str;

// }else{

board[i][j] = "╋";

// }

}

}

}

//输出棋盘

public void printBoard() {

for (int i = 0; i SIZE; i++) {

for (int j = 0; j SIZE; j++) {

System.out.print(board[i][j]);

}

System.out.println();

}

}

//判断所下棋子位置是否合理

public boolean isOk(int x, int y) {

boolean isRight = true;

if (x = 16 || x 1 || y = 16 | y 1) {

//System.out.println("输入错误，请从新输入");

isRight = false;

}

if (board[x][y].equals("●") || board[x][y].equals("○")) {

isRight = false;

}

return isRight;

}

//判断谁赢了

public void whoWin(Games wz) {

// 从数组挨个查找找到某个类型的棋子就从该棋子位置向右，向下，斜向右下 各查找5连续的位置看是否为5个相同的

int xlabel;// 记录第一次找到某个棋子的x坐标

int ylabel;// 记录第一次找到某个棋子的y坐标

// ●○╋

// 判断人是否赢了

for (int i = 0; i SIZE; i++) {

for (int j = 0; j SIZE; j++) {

if (board[i][j].equals("○")) {

xlabel = i;

ylabel = j;

// 横向找 x坐标不变 y坐标以此加1连成字符串

String heng = "";

if (i + 5 SIZE j + 5 SIZE) {

for (int k = j; k j + 5; k++) {

heng += board[i][k];

}

if (heng.equals("○○○○○")) {

System.out.println(roles+"赢了！您输了！");

System.exit(0);

}

// 向下判断y不变 x逐增5 连成字符串

String xia = "";

for (int l = j; l i + 5; l++) {

xia += board[l][j];

// System.out.println(xia);

}

if (xia.equals("○○○○○")) {

System.out.println(roles+"赢了！您输了！");

System.exit(0);

}

// 斜向右下判断

String youxia = "";

for (int a = 1; a = 5; a++) {

youxia += board[xlabel++][ylabel++];

}

if (youxia.equals("○○○○○")) {

System.out.println(roles+"赢了！您输了！");

System.exit(0);

}

}

}

}

}

// 判断电脑是否赢了

for (int i = 0; i SIZE; i++) {

for (int j = 0; j SIZE; j++) {

if (board[i][j].equals("●")) {

xlabel = i;

ylabel = j;

// 横向找 x坐标不变 y坐标以此加1连成字符串

String heng = "";

if (j + 5 SIZE i + 5 SIZE) {

for (int k = j; k j + 5; k++) {

heng += board[i][k];

}

if (heng.equals("●●●●●")) {

System.out.println(roles+"赢输了！您输了！");

System.exit(0);

}

// 向下判断y不变 x逐增5 连成字符串

String xia = "";

for (int l = i; l i + 5; l++) {

xia += board[l][ylabel];

// System.out.println(xia);

}

if (xia.equals("●●●●●")) {

System.out.println(roles+"赢了！您输了！");

System.exit(0);

}

// 斜向右下判断

String youxia = "";

for (int a = 1; a = 5; a++) {

youxia += board[xlabel++][ylabel++];

}

if (youxia.equals("●●●●●")) {

System.out.println(roles+"赢了！您输了！");

System.exit(0);

}

}

}

}

}

}

public static void main(String[] args) {

Games wz = new Games();

Scanner sc = new Scanner(System.in);

wz.initBoard();

wz.printBoard();

while (true) {

System.out.print("请"+roles+"输入X，Y坐标，必须在0－15范围内，xy以空格隔开,输入16 16结束程序");

int x = sc.nextInt();

int y = sc.nextInt();

if (x == SIZE y == SIZE) {

System.out.println("程序结束");

System.exit(0);

}

if (x SIZE || x 0 || y SIZE | y 0) {

System.out.println("输入错误，请从新输入");

continue;

}

//如果roles是A玩家 就让A玩家下棋，否则就让B玩家下棋。

if (wz.board[x][y].equals("╋")roles.equals("A玩家")) {

wz.board[x][y] = "○";

wz.printBoard();

//判断输赢

wz.whoWin(wz);

}else if(wz.board[x][y].equals("╋")roles.equals("B玩家")){

wz.board[x][y] = "●";

wz.printBoard();

//判断输赢

wz.whoWin(wz);

} else {

System.out.println("此处已经有棋子,从新输入");

continue;

}

if(roles.equals("A玩家")){

roles = "B玩家";

}else if(roles.equals("B玩家")){

roles = "A玩家";

}

}

}

}

JAVA设计的五子棋源程序

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import java.awt.geom.*;

import java.util.*;

class PaintPanel extends JPanel {

ArrayList Items = new ArrayList();

public PaintPanel() {

setLayout(new BorderLayout());

ButtonPanel buttonPanel = new ButtonPanel();

add(buttonPanel, BorderLayout.SOUTH);

addMouseListener(new MouseHandler());

}

public void paintComponent(Graphics g) {

int startX = 50;

int startY = 50;

boolean isMy = false;

super.paintComponent(g);

Graphics2D g2 = (Graphics2D)g;

for(int i=0; i16; i++) {

g2.draw(new Line2D.Double(startX, startY+20*i, startX+300, startY+20*i));

g2.draw(new Line2D.Double(startX+20*i, startY, startX+20*i, startY+300));

}

for(int i=0; iItems.size(); i++) {

isMy = !isMy;

if(isMy)

g2.setColor(Color.BLACK);

else

g2.setColor(Color.WHITE);

g2.fill((Ellipse2D)Items.get(i));

}

}

void myRepaint() {

repaint();

}

private class MouseHandler extends MouseAdapter {

public void mousePressed(MouseEvent event) {

int x = event.getX();

int y = event.getY();

paintItem(x, y);

repaint();

}

void paintItem(int x, int y) {

if(x 50 x 350 y 50 y 350) {

int X = x / 20;

int Y = y / 20;

int centerX = X*20 + 10;

int centerY = Y*20 + 10;

Ellipse2D ellipse = new Ellipse2D.Double();

ellipse.setFrameFromCenter(centerX, centerY, centerX+8, centerY+8);

Items.add(ellipse);

}

}

}

private class ButtonPanel extends JPanel {

public ButtonPanel() {

JButton reset = new JButton("Reset");

add(reset);

JButton quit = new JButton("Quit");

add(quit);

ResetEvent listenerR = new ResetEvent();

reset.addMouseListener(listenerR);

QuitEvent listenerQ = new QuitEvent();

quit.addMouseListener(listenerQ);

}

private class QuitEvent

extends MouseAdapter {

public void mouseClicked(MouseEvent event) {

System.exit(1);

}

}

private class ResetEvent

extends MouseAdapter {

public void mouseClicked(MouseEvent event) {

Items.clear();

myRepaint();

}

}

}

}

class GameFrame extends JFrame {

public GameFrame() {

setTitle("A Little Game");

setSize(400, 500);

setResizable(false);

PaintPanel panel = new PaintPanel();

getContentPane().add(panel);

}

} public class Game {

public static void main(String[] args) {

GameFrame frame = new GameFrame();

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.show();

}

}

//有缺陷，需要更加完善

新闻标题：五子棋java源代码包 五子棋的java代码
网站地址：http://azwzsj.com/article/doiipeg.html