JAVA 黑白棋

最新推荐文章于 2021-02-26 15:19:06 发布
最新推荐文章于 2021-02-26 15:19:06 发布
阅读量9.6k 收藏 32
点赞数 1
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011699990/article/details/53859293
版权

界面实现 文件读写 

主要是要判断放置一个棋子是否符合要求 

比如放置了一个黑色棋子 在水平、竖直、斜线方向上 找到一个黑色棋子  判断这两个棋子之间是否都是白色棋子

如果符合要求 则要将其中的白色棋子都转换为黑色棋子

package src;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.*;
import java.util.*;
import javax.swing.*;


/**
 * @author Lenovo
 * 构造方法  实现界面 为按钮添加事件监听器
 */
public class Othello extends JFrame{
	
	private boolean isBlackPlay=true;//是否是黑棋先手
	boolean gameover=false;
	private int blackChess=0,whiteChess=0;
	private int[][] data=new int[4][4];
	
	private JPanel p1=new JPanel();
	private JButton renewB=new JButton("重新开始");
	private JButton saveB=new JButton("保存");
	private JButton openB=new JButton("打开");
	private JButton exitB=new JButton("退出");
	
	private JPanel p2=new JPanel();
	private JButton button[][]=new JButton[4][4];
	
	public Othello(){
		Container c=this.getContentPane();
		c.add(p1, BorderLayout.NORTH);
		p1.add(renewB);
		p1.add(saveB);
		p1.add(openB);
		p1.add(exitB);
		
		c.add(p2, BorderLayout.CENTER);
		p2.setLayout(new GridLayout(4, 4));
		
		for(int i=0;i<4;i++){
			for(int j=0;j<4;j++){
				button[i][j]=new JButton("");
			}
		}
		for(int i=0;i<4;i++){
			for(int j=0;j<4;j++){
				p2.add(button[i][j]);
				button[i][j].setBackground(Color.GREEN);
				button[i][j].addActionListener(new Handler(i, j));
			}
		}
		
		button[1][1].setBackground(Color.WHITE);
		button[1][2].setBackground(Color.BLACK);
		button[2][1].setBackground(Color.BLACK);
		button[2][2].setBackground(Color.WHITE);
		
		renewB.addActionListener(new renewHandler());		
		saveB.addActionListener(new saveHandler());
		openB.addActionListener(new openHandler());
		exitB.addActionListener(new exitHandler());
	}
	
	/**
	 * @author Lenovo
	 * 实现重新开始按钮功能 初始化界面参数
	 */
	class renewHandler implements ActionListener{

		@Override
		public void actionPerformed(ActionEvent e) {
			// TODO Auto-generated method stub
			for(int i=0;i<4;i++){
				for(int j=0;j<4;j++){
					button[i][j].setBackground(Color.GREEN);
				}
			}
			button[1][1].setBackground(Color.WHITE);
			button[1][2].setBackground(Color.BLACK);
			button[2][1].setBackground(Color.BLACK);
			button[2][2].setBackground(Color.WHITE);
			
			isBlackPlay=true;
			blackChess=0;
			whiteChess=0;
		}
		
	}
	
	/**
	 * @author Lenovo
	 * 实现保存按钮的功能  将数据保存到文件
	 */
	class saveHandler implements ActionListener{

		@Override
		public void actionPerformed(ActionEvent e) {
			// TODO Auto-generated method stub
			for(int i=0;i<4;i++){
				for(int j=0;j<4;j++){
					if(button[i][j].getBackground()==Color.BLACK)
						data[i][j]=1;
					else if(button[i][j].getBackground()==Color.WHITE)
						data[i][j]=-1;
					else data[i][j]=0;//空白棋盘为0
				}
			}
			File file=new File("output.txt");
			try{
				BufferedWriter bw=new BufferedWriter(new FileWriter(file));
				for(int i=0;i<4;i++){
					for(int j=0;j<4;j++){
						if(j!=0)
							bw.write(",");
						bw.write(String.valueOf(data[i][j]));
					}
					bw.write("\r\n");
				}
				bw.write(isBlackPlay+"\r\n");
				bw.write("0表示空白，1表示黑棋，-1表示白棋。true表示该黑棋走了");
				bw.flush();
				bw.close();
			}catch (Exception e1) {
				// TODO: handle exception
				e1.printStackTrace();
			}
			
		}
		
	}
	
	/**
	 * @author Lenovo
	 * 实现打开按钮的功能 恢复文件中棋盘中的状态
	 */
	class openHandler implements ActionListener{

		@Override
		public void actionPerformed(ActionEvent e) {
			// TODO Auto-generated method stub
			try{
				File file=new File("output.txt");
				BufferedReader br=new BufferedReader(new FileReader(file));
				String line=br.readLine();
				int num=0;
				while(line!=null&&num<4){
					String[] temp=line.split(",");
					for(int i=0;i<temp.length;i++){
						data[num][i]=Integer.parseInt(temp[i]);
					}
					line=br.readLine();
					num++;
				}
				isBlackPlay=Boolean.parseBoolean(line);
				for(int i=0;i<4;i++){
					for(int j=0;j<4;j++){
						if(data[i][j]==1){
							button[i][j].setBackground(Color.BLACK);
						}else if(data[i][j]==-1){
							button[i][j].setBackground(Color.WHITE);
						}else{
							button[i][j].setBackground(Color.GREEN);
						}
					}
				}
				String s=new String();
				if(isBlackPlay)
					s="黑";
				else s="白";
				JOptionPane.showMessageDialog(null, "打开成功 后面到"+s+"方下");
			}catch (Exception e2) {
				// TODO: handle exception
				e2.printStackTrace();
			}
		}
	}
	
	class exitHandler implements ActionListener{

		@Override
		public void actionPerformed(ActionEvent e) {
			// TODO Auto-generated method stub
			System.exit(0);
		}
		
	}
	
	class Handler implements ActionListener{
		
		int row=-1,col=-1;
		
		public Handler(int x,int y){
			row=x;
			col=y;
		}
		
		private boolean isValidPosition(int x,int y){
			if(button[x][y].getBackground()!=Color.GREEN)
				return false;
			if(isBlackPlay==true){//黑方下
				for(int i=0;i<4;i++){//垂直方向判断
					if(button[i][y].getBackground()==Color.BLACK){
						if((i-x)>=2){
							int count=0;
							for(int k=x;k<i;k++){
								if(button[k][y].getBackground()==Color.white){
									count++;
								}
							}
							if(count==(i-x-1)){//如果两个黑子之间夹得都是白子
								return true;
							}
						}
						if((x-i)>=2){
							int count=0;
							for(int k=x;k>i;k--){
								if(button[k][y].getBackground()==Color.WHITE){
									count++;
								}
							}
							if(count==(x-i-1))
								return true;
						}
					}
				}
				//水平方向判断
				for(int j=0;j<4;j++){
					if(button[x][j].getBackground()==Color.BLACK){
						if((j-y)>=2){
							int count=0;
							for(int k=y;k<j;k++){
								if(button[x][k].getBackground()==Color.WHITE)
									count++;
							}
							if(count==(j-y-1))
								return true;
						}
						if((y-j)>=2){
							int count=0;
							for(int k=y;k>j;k--){
								if(button[x][k].getBackground()==Color.white)
									count++;
							}
							if(count==(y-j-1))
								return true;
						}
					}
				}
				//斜线方向上判断
				for(int i=0;i<4;i++){
					 for(int j=0;j<4;j++){
						 if(button[i][j].getBackground()==Color.BLACK){
							 if((x-i)==(y-j)&&(x-i)>=2){
								 int yy=y;
								 int count=0;
								 for(int k=x;k>i;k--){
									 if(button[k][yy].getBackground()==Color.WHITE)
										 count++;
									 yy--;
								 }
								 if(count==(x-i-1))
									 return true;
							 }
							 if((x-i)==(j-y)&&(x-i)>=2){
								 int yy=y;
								 int count=0;
								 for(int k=x;k>i;k--){
									 if(button[k][yy].getBackground()==Color.WHITE){
										 count++;
									 }
									 yy++;
								 }
								 if(count==(x-i-1))
									 return true;
							 }
							 if((i-x)==(y-j)&&(i-x)>=2){
								 int yy=y;
								 int count=0;
								 for(int k=x;k<i;k++){
									 if(button[k][yy].getBackground()==Color.WHITE)
										 count++;
									 yy--;
								 }
								 if(count==(i-x-1))
									 return true;
							 }
							 if((i-x)==(j-y)&&(i-x)>=2){
								 int yy=y;
								 int count=0;
								 for(int k=x;k<i;k++){
									 if(button[k][yy].getBackground()==Color.WHITE)
										 count++;
									 yy++;
								 }
								 if(count==(i-x-1))
									 return true;
							 }
						 }
					 }
				}
				return false;
			}
			else{
				for (int i = 0; i < 4; i++)
				{
					if (button[i][y].getBackground() == Color.WHITE)
					{
						if ((i - x) >= 2)
						{
							int count = 0;
							for (int k = x; k < i; k++)
							{
								if (button[k][y].getBackground() == Color.BLACK)
									count++;
							}
							if (count == (i - x - 1))
								return true;
						}
						if ((x - i) >= 2)
						{
							int count = 0;
							for (int k = x; k > i; k--)
							{
								if (button[k][y].getBackground() == Color.BLACK)
									count++;
							}
							if (count == (x - i - 1))
								return true;
						}
					}
				}

				for (int j = 0; j < 4; j++)
				{
					if (button[x][j].getBackground() == Color.WHITE)
					{
						if ((j - y) >= 2)
						{
							int count = 0;
							for (int k = y; k < j; k++)
							{
								if (button[x][k].getBackground() == Color.BLACK)
									count++;
							}
							if (count == (j - y - 1))
								return true;
						}

						if ((y - j) >= 2)
						{
							int count = 0;
							for (int k = y; k > j; k--)
							{
								if (button[x][k].getBackground() == Color.BLACK)
									count++;
							}
							if (count == (y - j - 1))
								return true;
						}

					}
				}

				for (int i = 0; i < 4; i++)
				{
					for (int j = 0; j < 4; j++)
					{
						if (button[i][j].getBackground() == Color.WHITE)
						{
							if ((x - i) == (y - j) && (x - i) >= 2)
							{
								int yy = y;
								int count = 0;
								for (int k = x; k > i; k--)
								{
									if (button[k][yy].getBackground() == Color.BLACK)
									{
										count++;
									}
									yy--;

								}
								if (count == (x - i - 1))
									return true;
							}

							if ((x - i) == (j - y) && (x - i) >= 2)
							{
								int yy = y;
								int count = 0;
								for (int k = x; k > i; k--)
								{
									if (button[k][yy].getBackground() == Color.BLACK)
									{
										count++;
									}
									yy++;

								}
								if (count == (x - i - 1))
									return true;
							}

							if ((i - x) == (y - j) && (i - x) >= 2)
							{
								int yy = y;
								int count = 0;
								for (int k = x; k < i; k++)
								{
									if (button[k][yy].getBackground() == Color.BLACK)
									{
										count++;
									}
									yy--;
								}
								if (count == (i - x - 1))
									return true;
							}

							if ((i - x) == (j - y) && (i - x) >= 2)
							{
								int yy = y;
								int count = 0;
								for (int k = x; k < i; k++)
								{
									if (button[k][yy].getBackground() == Color.BLACK)
									{
										count++;
									}
									yy++;
								}
								if (count == (i - x - 1))
									return true;
							}

						}
					}
				}

				return false;
			}
		}
		
		
		private void refresh(int x, int y)
		{
			if (isBlackPlay == true)// 若是黑方下
			{
				for (int i = 0; i < 4; i++)
				{
					if (button[i][y].getBackground() == Color.BLACK)
					{
						if ((i - x) >= 2)
						{
							int count = 0;
							for (int k = x; k < i; k++)
							{
								if (button[k][y].getBackground() == Color.WHITE)
									count++;
							}

							if (count == (i - x - 1))
							{
								for (int k = x; k < i; k++)
									button[k][y].setBackground(Color.BLACK);
							}

						}

						if ((x - i) >= 2)
						{
							int count = 0;// /
							for (int k = x; k > i; k--)
							{
								if (button[k][y].getBackground() == Color.WHITE)
									count++;
							}

							if (count == (x - i - 1))
							{
								for (int k = x; k > i; k--)
									button[k][y].setBackground(Color.BLACK);
							}
						}
					}
				}

				for (int j = 0; j < 4; j++)
				{
					if (button[x][j].getBackground() == Color.BLACK)
					{
						if ((j - y) >= 2)
						{
							int count = 0;
							for (int k = y; k < j; k++)
							{
								if (button[x][k].getBackground() == Color.WHITE)
									count++;
							}

							if (count == (j - y - 1))
							{
								for (int k = y; k < j; k++)
									button[x][k].setBackground(Color.BLACK);
							}
						}

						if ((y - j) >= 2)
						{
							int count = 0;
							for (int k = y; k > j; k--)
							{
								if (button[x][k].getBackground() == Color.WHITE)
									count++;
							}
							if (count == (y - j - 1))
							{
								for (int k = y; k > j; k--)
									button[x][k].setBackground(Color.BLACK);
							}
						}
					}
				}

				for (int i = 0; i < 4; i++)
				{
					for (int j = 0; j < 4; j++)
					{
						if (button[i][j].getBackground() == Color.BLACK)
						{
							if ((x - i) == (y - j) && (x - i) >= 2)
							{
								int yy = y;
								int count = 0;
								for (int k = x; k > i; k--)
								{
									if (button[k][yy].getBackground() == Color.WHITE)
									{
										count++;
									}
									yy--;

								}
								if (count == (x - i - 1))
								{
									yy = y;
									for (int k = x; k > i; k--)
									{
										button[k][yy].setBackground(Color.BLACK);
										yy--;
									}
								}
							}

							if ((x - i) == (j - y) && (x - i) >= 2)
							{
								int yy = y;
								int count = 0;
								for (int k = x; k > i; k--)
								{
									if (button[k][yy].getBackground() == Color.WHITE)
									{
										count++;
									}
									yy++;

								}
								if (count == (x - i - 1))
								{
									yy = y;
									for (int k = x; k > i; k--)
									{
										button[k][yy].setBackground(Color.BLACK);
										yy++;
									}
								}
							}

							if ((i - x) == (y - j) && (i - x) >= 2)
							{
								int yy = y;
								int count = 0;
								for (int k = x; k < i; k++)
								{
									if (button[k][yy].getBackground() == Color.WHITE)
									{
										count++;
									}
									yy--;

								}
								if (count == (i - x - 1))
								{
									yy = y;
									for (int k = x; k < i; k++)
									{
										button[k][yy].setBackground(Color.BLACK);
										yy--;
									}
								}
							}

							if ((i - x) == (j - y) && (i - x) >= 2)
							{
								int yy = y;
								int count = 0;
								for (int k = x; k < i; k++)
								{
									if (button[k][yy].getBackground() == Color.WHITE)
									{
										count++;
									}
									yy++;

								}
								if (count == (i - x - 1))
								{
									yy = y;
									for (int k = x; k < i; k++)
									{
										button[k][yy].setBackground(Color.BLACK);
										yy++;
									}
								}
							}

						}
					}
				}

			}
			else
			// 若是白方下
			{
				for (int i = 0; i < 4; i++)
				{
					if (button[i][y].getBackground() == Color.WHITE)
					{
						if ((i - x) >= 2)
						{
							int count = 0;
							for (int k = x; k < i; k++)
							{
								if (button[k][y].getBackground() == Color.BLACK)
									count++;
							}

							if (count == (i - x - 1))
							{
								for (int k = x; k < i; k++)
									button[k][y].setBackground(Color.WHITE);
							}

						}
						if ((x - i) >= 2)
						{
							int count = 0;
							for (int k = x; k > i; k--)
							{
								if (button[k][y].getBackground() == Color.BLACK)
									count++;
							}

							if (count == (x - i - 1))
							{
								for (int k = x; k > i; k--)
									button[k][y].setBackground(Color.WHITE);
							}
						}
					}
				}

				for (int j = 0; j < 4; j++)
				{
					if (button[x][j].getBackground() == Color.WHITE)
					{
						if ((j - y) >= 2)
						{
							int count = 0;
							for (int k = y; k < j; k++)
							{
								if (button[x][k].getBackground() == Color.BLACK)
									count++;
							}

							if (count == (j - y - 1))
							{
								for (int k = y; k < j; k++)
									button[x][k].setBackground(Color.WHITE);
							}
						}
						if ((y - j) >= 2)
						{
							int count = 0;
							for (int k = y; k > j; k--)
							{
								if (button[x][k].getBackground() == Color.BLACK)
									count++;
							}
							if (count == (y - j - 1))
							{
								for (int k = y; k > j; k--)
									button[x][k].setBackground(Color.WHITE);
							}
						}
					}
				}

				for (int i = 0; i < 4; i++)
				{
					for (int j = 0; j < 4; j++)
					{
						if (button[i][j].getBackground() == Color.WHITE)
						{
							if ((x - i) == (y - j) && (x - i) >= 2)
							{
								int yy = y;
								int count = 0;
								for (int k = x; k > i; k--)
								{
									if (button[k][yy].getBackground() == Color.BLACK)
									{
										count++;
									}
									yy--;
								}
								if (count == (x - i - 1))
								{
									yy = y;
									for (int k = x; k > i; k--)
									{
										button[k][yy].setBackground(Color.WHITE);
										yy--;
									}
								}
							}

							if ((x - i) == (j - y) && (x - i) >= 2)
							{
								int yy = y;
								int count = 0;
								for (int k = x; k > i; k--)
								{
									if (button[k][yy].getBackground() == Color.BLACK)
									{
										count++;
									}
									yy++;

								}
								if (count == (x - i - 1))
								{
									yy = y;
									for (int k = x; k > i; k--)
									{
										button[k][yy].setBackground(Color.WHITE);
										yy++;
									}
								}
							}
							if ((i - x) == (y - j) && (i - x) >= 2)
							{
								int yy = y;
								int count = 0;
								for (int k = x; k < i; k++)
								{
									if (button[k][yy].getBackground() == Color.BLACK)
									{
										count++;
									}
									yy--;

								}
								if (count == (i - x - 1))
								{
									yy = y;
									for (int k = x; k < i; k++)
									{
										button[k][yy].setBackground(Color.WHITE);
										yy--;
									}
								}
							}
							if ((i - x) == (j - y) && (i - x) >= 2)
							{
								int yy = y;
								int count = 0;
								for (int k = x; k < i; k++)
								{
									if (button[k][yy].getBackground() == Color.BLACK)
									{
										count++;
									}
									yy++;

								}
								if (count == (i - x - 1))
								{
									yy = y;
									for (int k = x; k < i; k++)
									{
										button[k][yy].setBackground(Color.WHITE);
										yy++;

									}
								}
							}

						}
					}
				}

			}

		}
		
		/**
		 * @return
		 * 判断是否还有位置可下
		 */
		private boolean hasValidPosition(){
			for(int i=0;i<4;i++){
				for(int j=0;j<4;j++){
					if(isValidPosition(i, j))
						return true;
				}
			}
			return false;
		}
		
		public void changePlayer(){
			if(isBlackPlay==true)
				isBlackPlay=false;
			else isBlackPlay=true;
		}
		
		private void whoWin(){
			for(int i=0;i<4;i++){
				for(int j=0;j<4;j++){
					if(button[i][j].getBackground()==Color.BLACK)
						blackChess++;
					if(button[i][j].getBackground()==Color.WHITE)
						whiteChess++;
				}
			}
			if(blackChess>whiteChess)
				JOptionPane.showMessageDialog(null, "恭喜黑方获胜！");
			else if(blackChess<whiteChess)
				JOptionPane.showMessageDialog(null, "恭喜白方获胜！");
			else 
				JOptionPane.showMessageDialog(null, "平局了！");
		}
		
		@Override
		public void actionPerformed(ActionEvent e) {
			// TODO Auto-generated method stub
			if(gameover==true){
				JOptionPane.showMessageDialog(null, "棋局已经结束 请重新开始");
				return;
			}else{
				if(!isValidPosition(row, col)){
					JOptionPane.showMessageDialog(null, "非法位置 请重新放置");
					return;
				}else{
					refresh(row, col);
					changePlayer();
					if(!hasValidPosition()){
						changePlayer();
						{
							if(!hasValidPosition()){
								gameover=true;
								whoWin();
							}else{
								JOptionPane.showMessageDialog(null, "对方已无处可下 己方继续");
								return;
							}
						}
					}
					else 
						return;
				}
			}
		}
		
	}
	
	
	public static void main(String[] args){
		Othello othello=new Othello();
		othello.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		othello.setSize(350,400);
		othello.setVisible(true);
	}
	
}


效果图：





  

理想主义文艺青年
关注
  • 1
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java黑白棋_JAVA——黑白棋简单实现
weixin_32394375的博客
02-12 382
packageReversi_JCoder;import java.awt.*;importjava.awt.Button;importjava.awt.Container;importjava.awt.event.ActionEvent;importjava.awt.event.ActionListener;import javax.swing.*;public class Reversi ex...
java黑白棋原码_JAVA课程设计黑白棋源代码
weixin_33201531的博客
02-25 975
JAVA课程设计黑白棋源代码JAVA课程设计黑白棋源代码|java课程设计|数据库课程设计|计算机课程设计|精品课程网站设计import java.awt.*;import javax.swing.*;import java.awt.event.*;//建立一个大框架用来放置棋盘面板class Game extends JFrame{int Max;//定义的棋盘大小为Max × Max的正方形b...
java实现的黑白棋
04-06
自己实现的黑白棋！！
JAVA实现黑白棋棋盘_学习一个月JAVA写的黑白棋程序（欢迎高手来指点）
weixin_39684235的博客
02-26 185
该楼层疑似违规已被系统折叠隐藏此楼查看此楼publicvoidclean(Graphicsg)//清屏{g.setColor(0xffffff);g.fillRect(0,0,180,177);}publicvoiddrawLogo(Graphicsg)//画LOGO{min++;if(ming.drawImage(sina,getWidth()/2,getHeight()/2,...
基于JAVA的黑白棋程序
04-24
1.SWT完成界面+音效支持 2.开局库支持 3.中局非负极大搜索 4.终局奇偶搜索 5.估值函数优化 6.无限悔棋功能 7.历史记录功能
java-黑白棋
03-06
java黑白棋，人机对弈，可直接使用还是比较好的，写了一个比较简单的算法
JAVA_heibaiqi.rar_java 黑白棋_java黑白棋_黑白棋 java_黑白棋JAVA源码
最新发布
09-23
【标签】中的关键词如"java_黑白棋"、"java黑白棋"、"黑白棋_java"和"黑白棋java源码"进一步强调了这个项目是关于使用Java语言实现的黑白棋游戏。这些标签方便开发者在搜索相关资源时找到这个项目，尤其是对于那些...
JAVA黑白棋游戏源代码
09-13
"JAVA黑白棋游戏源代码" 指的是一款使用Java编程语言编写的黑白棋（也称为翻转棋、反棋）游戏的完整源代码。黑白棋是一种双人对弈策略游戏，玩家通过翻转对方的棋子以达到最终占据棋盘多数棋子的目的。这里的源代码...
black_white_chess.rar_java黑白棋_white _黑白棋 java
09-14
【标题】"black_white_chess.rar_java黑白棋_white _黑白棋 java" 提供的信息表明，这是一个基于Java编程语言实现的黑白棋（也称反棋、翻转棋）游戏项目。这个项目的重点在于创建一个用户友好的图形界面，使得玩家...
java黑白棋（人人对战）
10-24
Java黑白棋游戏是一款基于Java编程语言开发的双人对战游戏。它允许两位玩家通过轮流翻转对方的棋子来争夺棋盘上的控制权。在这个游戏中，每一步操作都至关重要，因为策略性的布局和巧妙的反转是取胜的关键。下面我们...
java黑白棋
02-04
java编的开源的黑白棋<br>很弱智，不过是上班时偷工搞的.<br>嘻嘻.<br>其实我不会下黑白棋,瞎搞的.
简单的黑白棋（Java）
05-19
五子棋（Java） 简单的希望高手不要见笑
基于Java的黑白棋游戏的设计与实现
01-07
论文将详细介绍了基于Java 的黑白棋游戏的设计与实现所运用到的技术和相关知识，并对此次设计开发的过程和思路进行了论述。
Java黑白棋源代码程序
05-06
Java黑白棋源代码程序可以进行两人对战，可以悔棋，可以观看，是一个不错的程序，算法原创，有不足之处请大家原谅
java黑白棋(增强版)
02-06
java黑白棋(增强版) 开源! 可以修改THINK_LEVEL来改变pc思考步数加了简单的人机界面。support me! try!
JAVA——黑白棋简单实现
a15288862893的博客
10-21 1843
package Reversi_JCoder; import java.awt.*; import java.awt.Button; import java.awt.Container; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing...
一款java休闲小游戏--黑白棋
tempofwyq的专栏
04-21 3398
黑白棋是一款很休闲的游戏，规则简单易懂，核心就是将夹在自己棋子内的所有对方的棋子变成自己的，每一有效步都必须至少变对方一个子为自己的，直到一方再无法有效走动则结束，计算看那方的棋子多，则赢，可以平手。 　　学习java也熟练一段时间了，写一个放上来，启动后初始界面如下： 　　 　　然后就是行棋了，一人一步 　　 　　最后，黑棋完后白棋无法走了，棋局结束，计算结果 　　 　　 　　核心
JAVA黑白棋游戏设计与实现报告
"JAVA黑白棋课程设计文档包含了对黑白棋游戏的JAVA实现的详细过程，旨在提升学生的编程技能和面向对象的理解。课程设计的目标是巩固理论知识，提高独立编程能力，并激发对专业的热爱。设计任务包括掌握Java编程基础...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值