精华内容
下载资源
问答
  • Java井字游戏代码

    2018-04-07 09:36:20
    java&javafx;写的九宫格的井字游戏,有足够的代码解释
  • Java 井字游戏

    千次阅读 2019-08-29 11:34:10
    创建一个玩井字游戏的程序。程序提示两个玩家交替输入 X 和 O 标记。当输入一个标记时,程序在控制台上重新显示棋盘,然后确定游戏的状态(是获胜、平局还是继续)。

    编程练习题

    在井字游戏中,两个玩家使用各自的标志(一方用 X 则另一方就用 O ),轮流标记 3 × 3 3\times3 3×3 的网格中的某个空格。当一个玩家在网格的水平方向、垂直方向或者对角线方向上标记了三个相同的 X 或三个相同的 O 时,游戏结束,该玩家获胜。平局(没有赢家)是指当网格中所有的空格都被填满时没有玩家获胜的情况。

    网格坐标

     —————— —————— ——————
    |(0, 0)|(0, 1)|(0, 2)| 
     —————— —————— ——————
    |(1, 0)|(1, 1)|(1, 2)| 
     —————— —————— ——————
    |(2, 0)|(2, 1)|(2, 2)| 
     —————— —————— ——————
    

    创建一个玩井字游戏的程序。程序提示两个玩家交替输入 X 和 O 标记。当输入一个标记时,程序在控制台上重新显示棋盘,然后确定游戏的状态(是获胜、平局还是继续)。

    运行示例

     ——— ——— ———
    |   |   |   | 
     ——— ——— ———
    |   |   |   | 
     ——— ——— ———
    |   |   |   | 
     ——— ——— ———
    玩家 X :(行,列) = 1 1
    
     ——— ——— ———
    |   |   |   | 
     ——— ——— ———
    |   | X |   | 
     ——— ——— ———
    |   |   |   | 
     ——— ——— ———
    玩家 O :(行,列) = 0 0
    
     ——— ——— ———
    | O |   |   | 
     ——— ——— ———
    |   | X |   | 
     ——— ——— ———
    |   |   |   | 
     ——— ——— ———
    玩家 X :(行,列) = 1 0
    
    . . . . . . .
    
     ——— ——— ———
    | O | X |   | 
     ——— ——— ———
    | X | X | O | 
     ——— ——— ———
    | X | O | O | 
     ——— ——— ———
    玩家 X :(行,列) = 0 2
    
     ——— ——— ———
    | O | X | X | 
     ——— ——— ———
    | X | X | O | 
     ——— ——— ———
    | X | O | O | 
     ——— ——— ———
    玩家 X 获胜
    

    参考代码

    import java.util.Scanner;
    public class Game {
        private static Scanner input = new Scanner(System.in);
        public static void main(String[] args) {
            char[][] board = new char[3][3];
            displayBoard(board);
            while (true) {
                makeAMove(board, 'X');
                displayBoard(board);
                if (isWon('X', board)) {
                    System.out.println("玩家 X 获胜");
                    System.exit(1);
                }
                else if (isDraw(board)) {
                    System.out.println("平局");
                    System.exit(2);
                }
                makeAMove(board, 'O');
                displayBoard(board);
                if (isWon('O', board)) {
                    System.out.println("玩家 O 获胜");
                    System.exit(3);
                }
                else if (isDraw(board)) {
                    System.out.println("平局");
                    System.exit(4);
                }
            }
        }
        private static void makeAMove(char[][] board, char player) {
            boolean done = false;
            do {
                System.out.print("玩家 " + player + " :(行,列) = ");
                int row = input.nextInt();
                int column = input.nextInt();
                if (board[row][column] == '\0') {
                    board[row][column] = player;
                    done = true;
                }
                else
                    System.out.println("无效输入");
            }
            while (!done);
        }
        private static void displayBoard(char[][] board) {
            System.out.println("\n ——— ——— ———");
            for (int i = 0; i < 3; i++) {
                System.out.print("| ");
                for (int j = 0; j < 3; j++)
                    System.out.print(board[i][j] != '\0' ?  board[i][j] + " | ": "  | ");
                System.out.println("\n ——— ——— ———");
            }
        }
        private static boolean isWon(char ch, char[][] board) {
            for (int i = 0; i < 3; i++)
                if (ch == board[i][0] && ch == board[i][1] && ch == board[i][2])
                    return true;
            for (int j = 0; j < 3; j++)
                if (ch == board[0][j] && ch == board[1][j] && ch == board[2][j])
                    return true;
            if (ch == board[0][0] && ch == board[1][1] && ch == board[2][2])
                return true;
            return ch == board[0][2] && ch == board[1][1] && ch == board[2][0];
        }
        private static boolean isDraw(char[][] board) {
            for (int i = 0; i < 3; i++)
                for (int j = 0; j < 3; j++)
                    if (board[i][j] == '\0')
                        return false;
            return true;
        }
    }
    展开全文
  • 主要介绍了Java实现简单井字棋小游戏代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 井字游戏代码Java

    万次阅读 多人点赞 2016-11-23 22:47:49
    井字棋:读入一个整数,表示井字棋棋盘的边长。判断其中是否存在某一方获胜,获胜的条件是存在整行或整列或整条对角线或整条反对角线上是相同的棋子。如果存在,则输出代表获胜一方字母:X或O(大写字母X或O);如果...

    井字棋:读入一个整数,表示井字棋棋盘的边长。判断其中是否存在某一方获胜,获胜的条件是存在整行或整列或整条对角线或整条反对角线上是相同的棋子。如果存在,则输出代表获胜一方字母:X或O(大写字母X或O);如果没有任何一方获胜,则输出平局。
    ———《Java语言程序设计-基础篇》习题7.9

    package Tic-Tac-Toe;
    import java.util.Scanner;
    
    public class Ex7_9 {
            //i表示行数,j表示列数
         static int[][] x=new int[3][3];
         static int[][] o=new int[3][3];
         static int row;
         static int rank;
    
            //判断
            public static boolean judge(int[][] m,int i,int j){
                int num0=0;
                int num1=0;
                int num2=0;
                int num3=0;
                for(int l=0;l<3;l++){
                    //正对角线
                    if(i==j){
                    if(m[l][l]==1){
                        num0+=1;
                    }}
    
                    //反对角线
                    if(i==2-j){
                    if(m[l][2-l]==1){
                        num1+=1;
                    }}
                    //行
                    if(m[i][l]==1){
                        num2+=1;
                    }
                    //列
                    if(m[l][j]==1){
                        num3+=1;
                    }
                }
    
    
                if(num0==3||num1==3||num2==3||num3==3){
                    return true;
                }
                else
                    return false;
            }
    
    
            //输入位置
            static  void position(int[][] xo,int m,char player){
                  //记录玩家是o或x
                 //判断玩家
                Scanner input=new Scanner(System.in);
                System.out.print("玩家"+player+"输入行数:");
                row=input.nextInt()-1;
                System.out.print("玩家"+player+"输入列数:");
                rank=input.nextInt()-1;
                //判断该坐标上是否有棋子,如果有就重新输入,没有就赋值并输出
                if(row>2||rank>2||row<0||rank<0){
                    System.out.println("行数列数必须为1到3之间整数,请重新输入");
                    position(xo,m,player);
                }
                else if(x[row][rank]+o[row][rank]>0){
                    System.out.println("坐标重复,请重新输入");
                    position(xo,m,player);
                }
                else{
                    xo[row][rank]=1;
                    printMap();         //调用方法打印棋盘
                }           
            }
    
            //打印棋盘
            public static void printMap(){
                for(int i=0;i<3;i++){
                    for(int j=0;j<3;j++){
                        if(x[i][j]==1)
                            System.out.print(" x |");
                        else if(o[i][j]==1)
                            System.out.print(" o |");
                        else
                            System.out.print("   |");
                    }
                    System.out.println("");
                }
            }
    
            public static  void main(String[] args){
                boolean res=false;
                char player;
                //调用方法输入并判断胜利否
                for(int i=1;i<10;i++){
                    int m=i%2;              
                    //输入数值
                    if(m==0){
                        player='x';
                        position(x,m,'x');
                        res=judge(x,row,rank);//判断胜利否
                    }
                    else{
                        player='o';
                        position(o,m,'o');
                        res=judge(o,row,rank);}//判断胜利否
                    if(res){
                        System.out.println("玩家"+player+"获胜");
                        break;
    
                    }
                    else if(i==9){
                        System.out.println("平局");
                    }
                }   
            }
    }
    
    展开全文
  • 这个井字棋带有界面以及基础的判断算法,下法是人与人交互,但是可以修改成人机交互,所有的内容都很清晰,加了注释,可以参考一下
  • import java.awt; import javax.swing; import java.awt.event; import java.lang; import java.util; //import ... public class ChessFrame extends JFrame{ /// 游戏界面参数 private Container
  • 井字游戏无与伦比的游戏。 这款井字游戏是使用Android Studio开发的,Android Studio是Google Android操作系统的官方集成开发环境,专为Android开发而设计。 游戏本身允许两个人(玩家X和玩家O)再次竞争。 布局非常...
  • java swing游戏 大家好! 哇,自从我在这里发布了东西以来已经有一段时间了! 我必须说我真的很想写东西,我保证我不会再陷入“作家的障碍”。 希望 ..最近两个月发生了很多事情,我有很多话要说。 但是在这篇文章...

    java swing游戏

    大家好! 哇,自从我在这里发布了东西以来已经有一段时间了! 我必须说我真的很想写东西,我保证我不会再陷入“作家的障碍”。 希望 :) ..最近两个月发生了很多事情,我有很多话要说。 但是在这篇文章中,我只是要发布我之前写的一个小应用程序。 它是一个TicTacToe游戏应用程序。 从这个特定的程序中学到的东西不多,但是我真的想摆脱这种僵局,因此我今天就发布这个。

    我实际上写了这段代码是为了向我的一位朋友展示Java的一些非常酷的功能,这些朋友也以“ C ++”风格编写了相同的应用程序。 而且我的那个朋友甚至为计算机播放器开发了代码。 但是在完成他的代码后,他可悲地意识到了一个基本事实,即如果你玩的很好,你将无法在井字游戏中获胜! 呵呵 :D 所以我没有冒险进入那个领域。 老实说,我对编写AI应用程序并不十分感兴趣。 但由于我喜欢网络编程,因此我想到向此应用程序添加网络多人游戏功能。 但是很遗憾,我还没有时间这样做。
    Anywaiz应用程序的工作方式如下-游戏启动后即自动启动,状态栏指示现在轮到哪个玩家,剩下的只是简单的玩法! 在游戏结束时,该应用程序将自动重置。
    进入代码。

    import javax.swing.*;
    
    import java.awt.*;
    import java.awt.event.*;
    import java.util.logging.Logger;
    
    /**
    * TicTacToe Application
    * @author Steve Robinson
    * @version 1.0
    */
    
    class TicTacToeFrame extends JFrame
    {
    
     JButton [][] buttons= new JButton[3][3];
     JTextField statusBar;
     GamePanel panel;
     Integer turn;
     GameListener listener=new GameListener();
     Integer count;
    
     public TicTacToeFrame()
     {
      setLayout(new BorderLayout());
    
      panel=new GamePanel();
      add(panel,BorderLayout.CENTER);
    
      statusBar=new JTextField("Player1's Turn");
      statusBar.setEditable(false);
      add(statusBar,BorderLayout.SOUTH);
    
      setTitle("Tic Tac Toe!");
      setVisible(true);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      setBounds(400,400,300,300);
     }
    
     class GamePanel extends JPanel
     {
    
      public GamePanel()
      {
       setLayout(new GridLayout(3,3));
       turn =1;
       count=0;
       for(int i=0;i<3;i++)
        for(int j=0;j<3;j++)   {
         buttons[i][j]=new JButton();
         buttons[i][j].putClientProperty("INDEX", new Integer[]{i,j});
         buttons[i][j].putClientProperty("OWNER", null);
         buttons[i][j].addActionListener(listener);
         add(buttons[i][j]);
        }
      }
     }
    
     class GameListener implements ActionListener
     {
      public void actionPerformed(ActionEvent e)
      {
       count++;
       JButton b=(JButton)e.getSource();
       Integer[]index=(Integer[]) b.getClientProperty("INDEX");
    
       //System.out.println(turn); //turn                  //   //System.out.println("["+index[0]+"]"+"["+index[1]+"]");         //
       b.putClientProperty("OWNER", turn);
       Icon ico=new ImageIcon(turn.toString()+".gif");
       b.setIcon(ico);
       b.setEnabled(false);
       boolean result=checkVictoryCondition(index);
       if(result)
       {
        JOptionPane.showMessageDialog(null, "Player "+turn.toString()+" Wins");
        initComponents();
       }
       else
       {
        if(turn==1)
        {
         turn=2;
         statusBar.setText("Player2's Turn");
        }
        else
        {
         turn=1;
         statusBar.setText("Player1's Turn");
        }
       }
       if(count==9)
       {
        JOptionPane.showMessageDialog(null, "Match is a draw!");
        initComponents();
    
       }
    
      }
    
      Integer getOwner(JButton b)
      {
       return (Integer)b.getClientProperty("OWNER");
      }
    
      //PrintButtonMap for Diagnostics
      void printbuttonMap(Integer [][]bMap)
      {
       for(int i=0;i    for(int j=0;j     System.out.print(bMap[i][j]+" ");
        System.out.println("");
       }
      }
    
      boolean checkVictoryCondition(Integer [] index)
      {
       /*Integer[][]buttonMap=new Integer[][] {
         { getOwner(buttons[0][0]),getOwner(buttons[0][1]),getOwner(buttons[0][2])},
         { getOwner(buttons[1][0]),getOwner(buttons[1][1]),getOwner(buttons[1][2])},
         { getOwner(buttons[2][0]),getOwner(buttons[2][1]),getOwner(buttons[2][2])}
       };
    
       printbuttonMap(buttonMap); */
    
       Integer a=index[0];
                    Integer b=index[1];
       int i;
    
       //check row
       for(i=0;i<3;i++)  {
        if(getOwner(buttons[a][i])!=getOwner(buttons[a][b]))
         break;
       }
       if(i==3)
        return true;
    
       //check column
       for(i=0;i<3;i++)  {
        if(getOwner(buttons[i][b])!=getOwner(buttons[a][b]))
         break;
       }
       if(i==3)
        return true;
    
       //check diagonal
       if((a==2&&b==2)||(a==0&&b==0)||(a==1&&b==1)||(a==0&&b==2)||(a==2&&b==0))
       {
        //left diagonal
        for(i=0;i     if(getOwner(buttons[i][i])!=getOwner(buttons[a][b]))
          break;
        if(i==3)
         return true;
    
        //right diagonal
        if((getOwner(buttons[0][2])==getOwner(buttons[a][b]))&&(getOwner(buttons[1][1])==getOwner(buttons[a][b]))&&(getOwner(buttons[2][0])==getOwner(buttons[a][b])))
         return true;
    
        }
    
       return false;
    
      }
     }
    
    
    
     void initComponents()
     {
      for(int i=0;i<3;i++)   
                             for(int j=0;j<3;j++)  {
        buttons[i][j].putClientProperty("INDEX", new Integer[]{i,j});
        buttons[i][j].putClientProperty("OWNER",null);
        buttons[i][j].setIcon(null);
        buttons[i][j].setEnabled(true);
        turn=1;
        count=0;
        statusBar.setText("Player1's Turn");
    
       }
     }
    
    }
    
    class TicTacToe {
    
     public static void main(String[] args) {
      EventQueue.invokeLater(new Runnable(){
       public void run()
       {
        TicTacToeFrame frame=new TicTacToeFrame();
       }
      });
    
     }
    
    }

    该代码非常简单。 香港专业教育学院在按钮中使用两个属性来存储一些信息,用于检查获胜条件。 一个是“ OWNER”属性,该属性指示哪个用户当前拥有该正方形,而“ INDEX”属性则指示该正方形在网格中的索引(即[1,1],[1,2]…等)一个正方形,将更新OWNER属性,并使用所有按钮的OWNER属性检查victoryCondition。 其余代码不言自明。
    为第二个播放器添加键盘支持是一件非常容易的事。 正如他们所说的…“我把它留作练习”! 哈哈哈 :D 好吧,我真的希望我能花些时间,以便可以为该应用程序添加网络功能。

    干杯,

    史蒂夫。
    -
    我忘记附加将由应用程序使用的图像图标文件。 你可以在这里下载 http://www.mediafire.com/?d7d93v2342dxind 只需将内容提取到包含代码的文件夹中即可。 感谢我的朋友“ Gur Png”告诉我这件事。

    参考:来自我们JCG合作伙伴的 Java TicTacToe   Footy'n'Tech博客上的Steve Robinson。


    翻译自: https://www.javacodegeeks.com/2012/02/java-swing-tic-tac-toe.html

    java swing游戏

    展开全文
  • 一个简单的java井字游戏

    千次阅读 2018-05-23 22:42:08
    关于井字棋,大家都不陌生,主要是通过将井盘分为9块区域,一方一次选择一块区域,接着优先选择出连续的3块区域者获胜。其中我将9块区域分为1,2,3,4,5,6,7,8,9(正常的话将第一位设置为0更好),那么可以赢得游戏的...

    由于课堂上老师讲了一些相关算法,我也自学了一些swing组件的使用,于是心血来潮开始自己写一些游戏code。

    关于井字棋,大家都不陌生,主要是通过将井盘分为9块区域,一方一次选择一块区域,接着优先选择出连续的3块区域者获胜。

    其中我将9块区域分为1,2,3,4,5,6,7,8,9(正常的话将第一位设置为0更好),那么可以赢得游戏的选择方式有:

    横:1,2,3/4,5,6/7,8,9

    竖:1,4,7/2,5,8/3,6,9

    斜:1,5,9/3,5,7

    我的方法是:

    1,建立一个字符串数组,将以上方法放入一个数组中,同时建立一个int类型数组;

    2,建立相关的双方选择区域字符串数组,每选择一块区域,则在数组中添加这块区域的名称(即数字字符串);

    3,通过indexOf的方法(不懂的可以查询该方法的用法),来遍历确定能够完成的选择方式,进而在该int类型数组中通过+1的方式来确认各种方法的通用程度;

    4,通过遍历寻找该int类型数组是否有存在值为3的下标存在,则完成该方法,就可以确定输赢。

    附上我自己写的代码。

    import java.awt.Color;
    import java.awt.EventQueue;
    
    import javax.swing.JFrame;
    import javax.swing.JPanel;
    import javax.swing.JButton;
    import javax.swing.JLabel;
    import javax.swing.JOptionPane;
    import javax.swing.SwingConstants;
    import java.awt.event.ActionListener;
    import java.awt.event.ActionEvent;
    
    public class wellCover {
    
    	private JFrame frame;
    	private boolean jia = true;
    	JButton btnNewButton,btnNewButton_1,btnNewButton_2,button,button_1,button_2,button_3,button_4,button_5;
    	JLabel label;
    	private static String[] team;
    	private static String j[],y[];
    	private static int p,q;
    	private JButton button_8;
    	/**
    	 * Launch the application.
    	 */
    	public static void main(String[] args) {
    		team = new String[8];
    		//横
    		team[0] = "1,2,3";
    		team[1] = "4,5,6";
    		team[2] = "7,8,9";
    		//竖
    		team[3] = "1,4,7";
    		team[4] = "2,5,8";
    		team[5] = "3,6,9";
    		//斜
    		team[6] = "1,5,9";
    		team[7] = "3,5,7";
    		j = new String[5];
    		for(int i = 0;i < j.length;i++)
    			j[i] = "jia";
    		y = new String[5];
    		for(int i = 0;i < y.length;i++)
    			y[i] = "yi";
    		p=0;q=0;
    		EventQueue.invokeLater(new Runnable() {
    			public void run() {
    				try {
    					wellCover window = new wellCover();
    					window.frame.setVisible(true);
    				} catch (Exception e) {
    					e.printStackTrace();
    				}
    			}
    		});
    	}
    	public void sortS(String a[]){
    		int a1[] = new int[a.length];
    		for(int i = 0;i < a.length;i++)//赋值
    			a1[i] = Integer.parseInt(a[i]);
    		for(int i = 0;i < a1.length -1;i++)//排序
    			for(int j = i+1;j < a1.length;j++){
    				if(a1[i] >a1[j]){
    					int temp = a1[i];
    					a1[i] = a1[j];
    					a1[j] = temp;
    				}
    			}
    		for(int i = 0;i < a1.length;i++)//排序完后继续赋值
    			a[i] = String.valueOf(a1[i]);
    	}
    	public boolean win(String t[],String a[],String jia){
    		//先排序,再组合,接着遍历找出相关的
    		//遍历出所有的情况,接着有相同情况的,设置一个数组,下标所锁定的值加1
    		int tn[] = new int[t.length];
    		int index = 0;
    		for(int i = 0;i < a.length;i++){
    			for(int j = 0;j < t.length;j++){
    				if((index = t[j].indexOf(a[i])) != -1){//说明该点在该方法中存在
    					tn[j] += 1;//该方法次数出现+1
    				}
    			}
    		}
    		for(int i = 0;i < tn.length;i++){
    			if(tn[i] == 3){
    				//System.out.println(jia+"赢了!");
    				JOptionPane.showConfirmDialog(frame, jia+"赢了", "恭喜"+jia,  
    	                    JOptionPane.OK_OPTION);  
    				return true;
    			}	
    		}
    		
    		return false;
    	}
    	/**
    	 * Create the application.
    	 */
    	public wellCover() {
    		initialize();
    	}
    
    	/**
    	 * Initialize the contents of the frame.
    	 */
    	private void initialize() {
    		frame = new JFrame();
    		frame.setTitle("\u4E95\u5B57\u68CB\u5BF9\u6218");
    		frame.setBounds(100, 100, 548, 523);
    		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		frame.getContentPane().setLayout(null);
    		
    		JPanel panel = new JPanel();
    		panel.setBounds(48, 44, 435, 374);
    		frame.getContentPane().add(panel);
    		panel.setLayout(null);
    		
    		 btnNewButton = new JButton("1");
    		 btnNewButton.setBackground(Color.yellow);
    		btnNewButton.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent e) {
    				if(jia){
    					btnNewButton.setBackground(new Color(248,248,255));
    					j[p++]="1";
    					win(team,j,"甲");
    				}				
    				else{
    					btnNewButton.setBackground(new Color(0,0,0));
    					y[q++]="1";
    					win(team,y,"乙");
    				}
    					
    				btnNewButton.setEnabled(false);
    			}
    		});
    		btnNewButton.setBounds(0, 0, 144, 123);
    		panel.add(btnNewButton);
    		
    		 btnNewButton_1 = new JButton("2");
    		 btnNewButton_1.setBackground(Color.yellow);
    		btnNewButton_1.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent e) {
    				if(jia){
    					btnNewButton_1.setBackground(new Color(248,248,255));
    					j[p++]="2";
    					win(team,j,"甲");
    				}
    				else{
    					btnNewButton_1.setBackground(new Color(0,0,0));
    					y[q++]="2`";
    					win(team,y,"乙");
    				}
    				btnNewButton_1.setEnabled(false);
    			}
    		});
    		btnNewButton_1.setBounds(143, 0, 138, 123);
    		panel.add(btnNewButton_1);
    		
    		 btnNewButton_2 = new JButton("3");
    		 btnNewButton_2.setBackground(Color.yellow);
    		btnNewButton_2.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent e) {
    				if(jia){
    					btnNewButton_2.setBackground(new Color(248,248,255));
    					j[p++]="3";
    					win(team,j,"甲");
    				}
    				else{
    					btnNewButton_2.setBackground(new Color(0,0,0));
    					y[q++]="3";
    					win(team,y,"乙");
    				}
    				btnNewButton_2.setEnabled(false);
    			}
    		});
    		btnNewButton_2.setBounds(281, 0, 138, 123);
    		panel.add(btnNewButton_2);
    		
    		 button = new JButton("4");
    		 button.setBackground(Color.yellow);
    		button.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent e) {
    				if(jia){
    					button.setBackground(new Color(248,248,255));
    					j[p++]="4";
    					win(team,j,"甲");
    				}
    				else{
    					button.setBackground(new Color(0,0,0));
    					y[q++]="4";
    					win(team,y,"乙");
    				}
    				button.setEnabled(false);
    			}
    		});
    		button.setBounds(0, 120, 144, 123);
    		panel.add(button);
    		
    		 button_1 = new JButton("5");
    		 button_1.setBackground(Color.yellow);
    		button_1.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent e) {
    				if(jia){
    					button_1.setBackground(new Color(248,248,255));
    					j[p++]="5";
    					win(team,j,"甲");
    				}	
    				else{
    					button_1.setBackground(new Color(0,0,0));
    					y[q++]="5";
    					win(team,y,"乙");
    				}
    				button_1.setEnabled(false);
    			}
    		});
    		button_1.setBounds(143, 120, 138, 123);
    		panel.add(button_1);
    		
    		 button_2 = new JButton("6");
    		 button_2.setBackground(Color.yellow);
    		button_2.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent e) {
    				if(jia){
    					button_2.setBackground(new Color(248,248,255));
    					j[p++]="6";
    					win(team,j,"甲");
    				}	
    				else{
    					button_2.setBackground(new Color(0,0,0));
    					y[q++]="6";
    					win(team,y,"乙");
    				}
    				button_2.setEnabled(false);
    			}
    		});
    		button_2.setBounds(281, 120, 138, 123);
    		panel.add(button_2);
    		
    		 button_3 = new JButton("7");
    		 button_3.setBackground(Color.yellow);
    		button_3.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent e) {
    				if(jia){
    					button_3.setBackground(new Color(248,248,255));
    					j[p++]="7";
    					win(team,j,"甲");
    				}
    				else{
    					button_3.setBackground(new Color(0,0,0));
    					y[q++]="7";
    					win(team,y,"乙");
    				}
    				button_3.setEnabled(false);
    			}
    		});
    		button_3.setBounds(0, 241, 144, 123);
    		panel.add(button_3);
    		
    		 button_4 = new JButton("8");
    		 button_4.setBackground(Color.yellow);
    		button_4.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent e) {
    				if(jia){
    					button_4.setBackground(new Color(248,248,255));
    					j[p++]="8";
    					win(team,j,"甲");
    				}
    				else{
    					button_4.setBackground(new Color(0,0,0));
    					y[q++]="8";
    					win(team,y,"乙");
    				}
    				button_4.setEnabled(false);
    			}
    		});
    		button_4.setBounds(143, 241, 138, 123);
    		panel.add(button_4);
    		
    		 button_5 = new JButton("9");
    		 button_5.setBackground(Color.yellow);
    		button_5.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent e) {
    				if(jia){
    					button_5.setBackground(new Color(248,248,255));
    					j[p++]="9";
    					win(team,j,"甲");
    				}
    				else{
    					button_5.setBackground(new Color(0,0,0));
    					y[q++]="9";
    					win(team,y,"乙");
    				}
    				button_5.setEnabled(false);
    			}
    		});
    		button_5.setBounds(281, 241, 138, 123);
    		panel.add(button_5);
    		
    		JLabel lblNewLabel = new JLabel("\u5BF9\u6218\u53CC\u65B9\uFF1A\u7532\uFF0C\u4E59");
    		lblNewLabel.setHorizontalAlignment(SwingConstants.CENTER);
    		lblNewLabel.setBounds(82, 0, 324, 31);
    		frame.getContentPane().add(lblNewLabel);
    		
    		JButton button_6 = new JButton("\u6094\u68CB");
    		button_6.setBounds(29, 438, 113, 27);
    		frame.getContentPane().add(button_6);
    		
    		JButton button_7 = new JButton("\u4EA4\u6362\u53CC\u65B9");
    		button_7.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent e) {
    				if(jia){
    					jia = false;
    					label.setText("当前轮到乙");
    					return;
    				}
    				else{
    					jia = true;
    					label.setText("当前轮到甲");
    					return;
    				}
    				
    			}
    		});
    		button_7.setBounds(156, 438, 113, 27);
    		frame.getContentPane().add(button_7);
    		
    		label = new JLabel("\u5F53\u524D\u8F6E\u5230\u7532");
    		label.setHorizontalAlignment(SwingConstants.CENTER);
    		label.setBounds(309, 431, 174, 29);
    		frame.getContentPane().add(label);
    		
    		button_8 = new JButton("\u91CD\u65B0\u5F00\u59CB");//重新开始按钮
    		button_8.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent e) {
    				btnNewButton.setEnabled(true);
    				btnNewButton_1.setEnabled(true);
    				btnNewButton_2.setEnabled(true);
    				button.setEnabled(true);
    				button_1.setEnabled(true);
    				button_2.setEnabled(true);
    				button_3.setEnabled(true);
    				button_4.setEnabled(true);
    				button_5.setEnabled(true);
    				btnNewButton.setBackground(Color.yellow);
    				btnNewButton_1.setBackground(Color.yellow);
    				btnNewButton_2.setBackground(Color.yellow);
    				button.setBackground(Color.yellow);
    				button_1.setBackground(Color.yellow);
    				button_2.setBackground(Color.yellow);
    				button_3.setBackground(Color.yellow);
    				button_4.setBackground(Color.yellow);
    				button_5.setBackground(Color.yellow);
    				//恢复默认值
    				j = new String[5];
    				for(int i = 0;i < j.length;i++)
    					j[i] = "jia";
    				y = new String[5];
    				for(int i = 0;i < y.length;i++)
    					y[i] = "yi";
    				p=0;q=0;
    			}
    		});
    		button_8.setBounds(14, 13, 113, 27);
    		frame.getContentPane().add(button_8);
    	}
    }
    
    第一次写博客!如果有缺点请大家踊跃批评我!~
    展开全文
  • Java Swing井字游戏

    2020-05-03 23:05:39
    大家好! 哇,自从我在这里发布了东西以来已经有一段时间了! 我必须说我真的很想写东西,而且我保证我不会再陷入“作家的障碍”。 希望 ..最近两个月发生了很多事情,我有很多话要说... 我实际上写了这段代码是为了...
  • 适用于Android的井字游戏。 该项目使用我的游戏控制台Java版本的代码。 所有没有输出/输入的类都移至该项目。 该应用程序只有一个屏幕。 游戏使用3到3字段的标准规则。 您可以与人类或CPU对抗(这使用简单的随机...
  • Tic-Tac-Toe-Game-In-Java:这是井字游戏的完整源代码
  • Java井字游戏实现

    千次阅读 2017-07-20 23:07:07
    你的程序先要读入一个整数n,范围是[3,100],这表示井字棋棋盘的边长。比如n=3就表示是一个3x3的棋盘。然后,要读入n行,每行n个数字,每个数字是1或0,依次表示[0,0]到[n-1,n-1]位置上的棋子。1表示X,0表示O(大写...
  • 简单的java游戏源码 Tic-Tac-Toe2.0 Java source code for simple tic tac toe game.
  • JAVA 井字

    千次阅读 2019-03-09 17:09:40
    有时候我们可以用java编写一些小游戏,比如井字棋,这是一个很简单的程序,如图效果; 我们可以将它分为棋子,棋盘,框架启动类表示; 首先我们来编写棋子类,棋子类里有棋子的坐标和形状的表示, 用1表示圆圈...
  • java写的游戏源码
  • 井字游戏 Java中的一个简单的井字游戏
  • java井字游戏——逐步进阶

    千次阅读 2018-10-21 11:01:36
    井字游戏 首先分解任务: 1.如何来显示井字棋的棋盘 2.创建一个3X3的矩阵(chessPiece)来实时记录两个棋手的走棋 3.对异常情况的捕获,用户的输入可能存在哪些不合法的情况 4.怎样判断最终是谁赢了,或者平局 ...
  • 首次尝试使用Java脚本玩井字游戏 我们将对小学经典的“剪刀石头布”进行简单的实现。 如果您不知道那是什么,请查看Wikipedia文章或此荒谬的分步指南。 目前,我们只是要从浏览器控制台玩游戏,但是我们将在以后的...
  • JAVA游戏——双人井字棋 import java.util.Scanner; public class Programming2 { // 建立可存入位置的数组 static int[][] x=new int[3][3]; static int[][] o=new int[3][3]; public static void main ...
  • 读入一个整数,表示井字棋棋盘的边长。判断其中是否存在某一方获胜,获胜的条件是存在整行或整列或整条对角线或整条反对角线上是相同的棋子。如果存在,则输出代表获胜一方字母:X或O(大写字母X或O);如果没有任何...
  • 能够实时输出,不允许重复落子,有判断... 1 package 井字游戏; 2 import java.util.*; 3 4 public class mine { 5 public static void main(String[] args) { 6 char[][] array = {{' ',' ',' '},{' ',...
  • Java 井字棋小结

    2019-08-02 09:23:31
    1.井字棋获胜的四种情况 横行全为同一符号 竖行全为同一符号 斜对角线为同一符号 反对角线为同一符号 2.编程思路 构建数组(二维)读入数据 分四个部分,分别判断横行,竖行,对角线,反对角线是否满足条件 ...
  • 基于java语言实现的人工只能小游戏井字棋,里面包含源码和简单的程序介绍。
  • 井字游戏是一款小时候的游戏,一张纸就能玩,本文主要介绍了基于jsp的井字游戏实例,有兴趣的同学可以来看一下。
  • java——博弈算法实现井字游戏

    千次阅读 2020-04-05 15:31:42
    通过java语言开发了一个简单的井字游戏。主要有6个类,其中有一个是主类(Main.java),一个是抽象类(PiecesMove.java)组成。 下面对各个类简单介绍一下: TicTicToe.java: 主要负责创建棋盘,管理棋盘。 ...
  • ...java实训 井字过三关 简单。。。。。。。。。。。。。。。。。。。。。
  • 井字游戏 代码分析

    千次阅读 2005-08-28 09:17:00
    Visual C++.NET 2003程序员:黄江斌程序功能:井字棋小游戏,人机对战版时间:2005年8月28日 界面如下图: 程序分析: CtictactoeView::CtictactoeView()//程序中关键变量赋初值{ // TODO: 在此处添加构造代码 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 981
精华内容 392
关键字:

java井字游戏代码

java 订阅