高考报名时间2022年11月1日还剩 天 距离2023年6月7日高考还有 天
栏目分类:
子分类:
返回
名师互学网用户登录
名师互学网
快速导航关闭
当前搜索
当前分类
前沿技术 软件开发 系统运维 产品运营 生活办公 面试经验 考试题库
子分类
人工智能 大数据 云计算 区块链 物联网 深度学习 机器学习 NLP 计算机视觉 语音识别 其他 大数据系统 数据可视化 数据挖掘与分析 其他 Docker/k8s 虚拟化 云平台 其他 基本原理 数字货币 智能合约 EOS应用 其他 通讯技术 嵌入式开发 单片机 物联网应用 HarmonyOS 其他 后端开发 Web开发 移动开发 游戏开发 Python Java 架构设计 C/C++/C# PHP .Net Go语言 R语言
实用工具
学习工具 小学数学练习 字帖生成 在线画板 函数绘制 拼音字母表 在线词典 黄历查询 亲戚关系计算 安全期计算 中国历史 Excel函数 模拟请求 json格式化 浏览器指纹
热门搜索
路由器设置 木托盘 宝塔面板 儿童python教程 心情低落 朋友圈 vim 双一流学科 专升本 我的学校 日记学校 西点培训学校 汽修学校 情书 化妆学校 塔沟武校 异形模板 西南大学排名 最精辟人生短句 6步教你追回被骗的钱 南昌大学排名 清朝十二帝 北京印刷学院排名 北方工业大学排名 北京航空航天大学排名 首都经济贸易大学排名 中国传媒大学排名 首都师范大学排名 中国地质大学(北京)排名 北京信息科技大学排名
名师互学网 > IT > 软件开发 > 后端开发 > Java

javafx逻辑实现五子棋基本功能（悔棋，重新开始，保存棋谱，复盘，人人对战，单机模式

Java 更新时间： 发布时间： IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

javafx逻辑实现五子棋基本功能（悔棋，重新开始，保存棋谱，复盘，人人对战，单机模式

javafx逻辑实现五子棋基本功能（悔棋，重新开始，保存棋谱，复盘，人人对战，单机模式）

做这个项目，本身目的仅仅是想应用学过的知识做个小项目，想知道它们在实际开发中应该如何应用，顺便帮我对几个月来的学习的知识更深入的了解。等我学完了数据库，再做个更大的项目，应该不成问题。所以，这篇文章适合学完Java基础的人学习，这也是我对自己Java学习第一阶段做的总结。

这是关于棋子文件上传代码

saveButton.setOnAction(new EventHandler() {
            @Override
            public void handle(ActionEvent event) {

                //创建保存框对象
                FileChooser fileChooser=new FileChooser();
                if(!isWin)
                    return;

                //展示Window window = ;
                File file=fileChooser.showSaveDialog(stage);
                BufferedWriter bw=null;

                if (file!=null){
                    try {
                        bw=new BufferedWriter(new FileWriter(file) );
                        //一次写一个字符串
                        for (int i=0;i 

复盘代码
 

 replay.setOnAction(new EventHandler() {
            @Override
            public void handle(ActionEvent event) {
                //首先应该在点击复盘的时候清空所有棋子
                //怎么删除呢，怎么添加怎么删除，pane.getChildren()是一个单列集合
                pane.getChildren().removeIf(new Predicate() {
                    @Override
                    public boolean test(Object obj) {
                        return obj instanceof Circle;
                    }
                });
                //清空了，为什么会是白子先走,而且有些地方仍旧显示有棋子
                isBLACK=true;
                chesses =new Chess[100];
                count=0;
                isWin=false;

                FileChooser fileChooser=new FileChooser();
                file=fileChooser.showOpenDialog(stage);
                if (file!=null) {
                    //关闭画板鼠标点击事件
                    pane.setOnMouseClicked(new EventHandler() {
                        @Override
                        public void handle(MouseEvent event) {
                            return;
                        }
                    });
                    Button up = up();
                    pane.getChildren().add(up);
                    Button down = down();
                    pane.getChildren().add(down);
                    movingdown(down);
                    movingup(up);
                }
                else
                    return;
            }
        });
 
单机模式完整代码 

package com.zht.ui.single;


import com.zht.domain.Chess;
import javafx.application.Application;
import javafx.application.Platform;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.Scene;
import javafx.scene.control.alert;
import javafx.scene.control.Button;

import javafx.scene.control.Label;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.Background;
import javafx.scene.layout.BackgroundFill;
import javafx.scene.layout.Pane;
import javafx.scene.paint.Color;
import javafx.scene.shape.Circle;
import javafx.scene.shape.Line;
import javafx.stage.FileChooser;
import javafx.stage.Stage;


import java.io.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Timer;
import java.util.TimerTask;
import java.util.function.Predicate;


public class SingleUI extends Application {
    private boolean isBLACK=true;
    private Chess[] chesses=new Chess[100];//装棋子的容器

    private int count=0;//棋盘上妻子个数
    private int iswincount=1;
    private boolean isWin=false;
    private Stage stage=null;
    private Pane pane=null;
    Scanner scanner=null;

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


    public void start (Stage stage) {
        this.stage=stage;
        //获取画板
        this.pane=getPane();
        pane.setBackground(new Background(new BackgroundFill(Color.BISQUE,null,null)));

        //给画板对象，绑定鼠标点击事件，就可以执行某些动作
        moveInChess(pane);

        //创建场景对象，把画板对象放进去
        Scene scene=new Scene(pane,850,860);
        stage.setScene(scene);
        stage.show();
    }

    private void moveInChess(Pane pane) {
        pane.setOnMouseClicked(new EventHandler(){
            //当鼠标点击画板，就会执行该方法
            @Override
            public void handle(MouseEvent event) {
                //注意这里
                if (isWin){
                    return;
                }


                //获取鼠标点击位置x和y的坐标
                double x=event.getX();
                double y=event.getY();
                if(!(x>=50&&x<=750&&y>=50&&y<=750)){
                    return;
                }
                else{
                int x1=(int)((x+25)/50)*50;
                int y1=(int)((y+25)/50)*50;
                //判断x和y上是否有棋子,使棋子无法同时在一点
                if(isHas(x1,y1)){
                    System.out.println("该位置有棋子");
                    return;
                }
                Circle circle=null;
                Chess chess=null;
                if(isBLACK){
                    circle=new Circle(x1,y1,15, Color.BLACK);
                    isBLACK=false;
                    chess=new Chess(x1,y1,Color.BLACK);
                }
                else {
                circle=new Circle(x1,y1,15, Color.WHITE);
                isBLACK=true;
                chess=new Chess(x1,y1,Color.WHITE);
                }
                pane.getChildren().add(circle);
                //向容器里放一个棋子对象
                chesses[count]=chess;
                count++;
                if(isWin(chess)){
                    //System.out.println("胜利了");
                    //弹窗
                    alert alert=new alert(alert.alertType.INFORMATION);
                    alert.setContentText("五子棋大师！！！！！！");
                    alert.showAndWait();
                    isWin=true;
                }
            }

        }});
    }

    //当落完子后，连续超过5个同颜色棋子即为胜利
    private boolean isWin(Chess chess){
        int x=chess.getX();
        int y=chess.getY();
        //向右
        for (int i=x+50;i<=x+200&&i<750;i+=50){
            //判断这个位置，有没有棋子，颜色是什么
            Chess _chess=getChess(i,y);
            if(_chess!=null&&chess.getColor().equals(_chess.getColor())){
                iswincount++;
            }
            else {
                break;
            }

        }
        //向左
        for (int i=x-50;i>=x-200&&i>=0;i-=50){
            //判断这个位置，有没有棋子，颜色是什么
            Chess _chess=getChess(i,y);
            if(_chess!=null&&chess.getColor().equals(_chess.getColor())){
                iswincount++;
            }
            else {
                break;
            }

        }
        if(iswincount>=5){
            iswincount=1;

            return true;

        }

        iswincount=1;
        //判断垂直方向
        for (int i=y+50;i<=y+200&&i<800;i+=50){
            //判断这个位置，有没有棋子，颜色是什么
            Chess _chess=getChess(x,i);
            if(_chess!=null&&chess.getColor().equals(_chess.getColor())){
                iswincount++;
            }
            else {
                break;
            }

        }
        for (int i=y-50;i>=y-200&&i>=0;i-=50){
            //判断这个位置，有没有棋子，颜色是什么
            Chess _chess=getChess(x,i);
            if(_chess!=null&&chess.getColor().equals(_chess.getColor())){
                iswincount++;
            }
            else {
                break;
            }

        }
        if(iswincount>=5){
            iswincount=1;

            return true;

        }

        iswincount=1;
        //判断右斜
        for (int i=x+50, j=y+50;i<=x+200&&i<750&&j<=y+200&&j<750;i+=50,j+=50){
            //判断这个位置，有没有棋子，颜色是什么
            Chess _chess=getChess(i,j);
            if(_chess!=null&&chess.getColor().equals(_chess.getColor())){
                iswincount++;
            }
            else {
                break;
            }

        }
        for (int i=y-50,j=x-50;i>=y-200&&i>=0&&j>=x-200&&j>=0;i-=50,j-=50){
            //判断这个位置，有没有棋子，颜色是什么
            Chess _chess=getChess(j,i);
            if(_chess!=null&&chess.getColor().equals(_chess.getColor())){
                iswincount++;
            }
            else {
                break;
            }

        }
        if(iswincount>=5){
            iswincount=1;

            return true;

        }

        iswincount=1;
        //判断左斜
        for (int i=x+50, j=y-50;i<=x+200&&i<750&&j>=y-200&&j>=0;i+=50,j-=50){
            //判断这个位置，有没有棋子，颜色是什么
            Chess _chess=getChess(i,j);
            if(_chess!=null&&chess.getColor().equals(_chess.getColor())){
                iswincount++;
            }
            else {
                break;
            }

        }
        for (int i=x-50, j=y+50;i>=x-200&&i>=0&&j<=y+200&&j<=750;i-=50,j+=50){
            //判断这个位置，有没有棋子，颜色是什么
            Chess _chess=getChess(i,j);
            if(_chess!=null&&chess.getColor().equals(_chess.getColor())){
                iswincount++;
            }
            else {
                break;
            }

        }
        if(iswincount>=5){
            iswincount=1;

            return true;

        }

        iswincount=1;
        return  false;
    }
    //封装的方法，如果找到返回chess,没有返回null
    //获取指定坐标的棋子对象
    private Chess getChess(int x,int y){
        //定义个容器
        for (int i=0;i() {
            @Override
            public void handle(ActionEvent event) {
                if (!isWin)
                    return;
                //怎么删除呢，怎么添加怎么删除，pane.getChildren()是一个单列集合
                pane.getChildren().removeIf(new Predicate() {
                    @Override
                    public boolean test(Object obj) {
                        return obj instanceof Circle;
                    }
                });
                //清空了，为什么会是白子先走,而且有些地方仍旧显示有棋子
                isBLACK=true;
                chesses =new Chess[100];
                count=0;
                isWin=false;
            }

        });
        pane.getChildren().add(startButton);


        //获得悔棋的按钮对象
        //悔棋，这里要理解迭代器
        Button backButton=backButton();
        backButton.setOnAction(new EventHandler() {
            @Override
            public void handle(ActionEvent event) {
                if (isWin)
                    return;
                Iterator it=pane.getChildren().iterator();
                Object obj=null;
                while (it.hasNext()){
                     obj=it.next();

                }
                if (obj instanceof Circle){
                it.remove();

                }
                if (isBLACK==false)
                    isBLACK=true;
                else
                    isBLACK=false;
                chesses =new Chess[100];
                count=0;

                isWin=false;

            }
        });
        pane.getChildren().add(backButton);


        //获取保存棋谱的按钮对象

        Button saveButton=getsaveButton();
        saveButton.setOnAction(new EventHandler() {
            @Override
            public void handle(ActionEvent event) {

                //创建保存框对象
                FileChooser fileChooser=new FileChooser();
                if(!isWin)
                    return;

                //展示Window window = ;
                File file=fileChooser.showSaveDialog(stage);
                BufferedWriter bw=null;

                if (file!=null){
                    try {
                        bw=new BufferedWriter(new FileWriter(file) );
                        //一次写一个字符串
                        for (int i=0;i() {
            @Override
            public void handle(ActionEvent event) {
                //首先应该在点击复盘的时候清空所有棋子
                //怎么删除呢，怎么添加怎么删除，pane.getChildren()是一个单列集合
                pane.getChildren().removeIf(new Predicate() {
                    @Override
                    public boolean test(Object obj) {
                        return obj instanceof Circle;
                    }
                });
                //清空了，为什么会是白子先走,而且有些地方仍旧显示有棋子
                isBLACK=true;
                chesses =new Chess[100];
                count=0;
                isWin=false;

                FileChooser fileChooser=new FileChooser();
                file=fileChooser.showOpenDialog(stage);
                if (file!=null) {
                    //关闭画板鼠标点击事件
                    pane.setOnMouseClicked(new EventHandler() {
                        @Override
                        public void handle(MouseEvent event) {
                            return;
                        }
                    });
                    Button up = up();
                    pane.getChildren().add(up);
                    Button down = down();
                    pane.getChildren().add(down);
                    movingdown(down);
                    movingup(up);
                }
                else
                    return;
            }
        });
        pane.getChildren().add(replay);


        //获取时间对象
        
        Label label=new Label();
        label.setLayoutX(250);
        label.setLayoutY(0);
        Timer timer=new Timer();


        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                //获取当前时间
                LocalDateTime localDateTime=LocalDateTime.now();
                DateTimeFormatter pattern=DateTimeFormatter.ofPattern("yyyy-MM-dd   HH:mm:ss");
                String time=localDateTime.format(pattern);
                Platform.runLater(new Runnable() {
                    @Override
                    public void run() {
                        label.setText(time);
                    }
                });
            }
        },0,1000);
        pane.getChildren().add(label);
        return pane;
    }

    public void movingup(Button up){
        up.setOnAction(new EventHandler() {
            @Override
            public void handle(ActionEvent event) {
                if (isWin)
                    return;
                Iterator it = pane.getChildren().iterator();

                Object obj = null;
                while (it.hasNext()) {
                    obj = it.next();


                }
                if (obj instanceof Circle) {
                    it.remove();


                }
                if (!isBLACK)
                    isBLACK = true;
                else
                    isBLACK = false;
                chesses = new Chess[100];
                count = 0;

                isWin = false;
            }
        });

    }
    public void movingdown(Button down) {

        try {
            scanner = new Scanner(new FileInputStream(file));

            down.setOnAction(new EventHandler() {
                @Override
                public void handle(ActionEvent event) {
                    Circle circle=null;


                    String line=null;
                    if ((line = scanner.nextLine()) != null) {
                        String[] strs = line.split(",");
                        if (strs[2].equals("0x000000ff"))
                            circle = new Circle(Integer.parseInt(strs[0]), Integer.parseInt(strs[1]), 15, Color.BLACK);
                        else
                            circle = new Circle(Integer.parseInt(strs[0]), Integer.parseInt(strs[1]), 15, Color.WHITE);
                        pane.getChildren().add(circle);


                    }


                }
            });
        } catch (FileNotFoundException e) {
            System.out.println("已经到头啦！");
    }
    }


    private Button down(){
        Button up=new Button(">");
        up.setPrefSize(40,30);
        up.setLayoutX(780);
        up.setLayoutY(560);
        return up;
    }
    private Button up(){
        Button up=new Button("<");
        up.setPrefSize(40,30);
        up.setLayoutX(780);
        up.setLayoutY(500);
        return up;
    }

    private  Button replayButton(){
        Button replay=new Button("复盘");
        replay.setPrefSize(100,50);
        replay.setLayoutX(500);
        replay.setLayoutY(780);
        return replay;
    }
    private  Button getsaveButton(){
        Button saveButton=new Button("保存棋谱");
        saveButton.setPrefSize(100,50);
        saveButton.setLayoutX(350);
        saveButton.setLayoutY(780);
        return saveButton;
    }
    private Button backButton() {
        Button backButton=new Button("悔棋");
        backButton.setPrefSize(100,50);
        backButton.setLayoutX(200);
        backButton.setLayoutY(780);
        return backButton;
    }

    private Button getButton() {
        Button startButton=new Button("再来一局");
        startButton.setPrefSize(100,50);
        startButton.setLayoutX(50);
        startButton.setLayoutY(780);
        return startButton;
    }

}


 
单机版实体类 

package com.zht.domain;//真正的面向对象思想
import javafx.scene.paint.Color;

public class Chess {
    private int x;
    private int y;
    private Color color;
    public Chess(){}
    public Chess(int x,int y,Color color){
        this.x=x;
        this.y=y;
        this.color=color;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Chess chess = (Chess) o;
        return x == chess.x && y == chess.y && color.equals(chess.color);
    }

    @Override
    public int hashCode() {
        return 0;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public String getColor() {
        return color.toString();
    }

    public void setColor(Color color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "com.Chess{" +
                "x=" + x +
                ", y=" + y +
                ", color=" + color +
                '}';
    }
}


 
套接字编程 


 想要看到更多的代码，请
 完整代码请点击此处







转载请注明：文章转载自 www.mshxw.com















Java相关栏目本月热门文章












热门相关搜索






路由器设置
木托盘
宝塔面板
儿童python教程
心情低落
朋友圈
vim
双一流学科
专升本
我的学校
日记学校
西点培训学校
汽修学校
情书
化妆学校
塔沟武校
异形模板
西南大学排名
最精辟人生短句
6步教你追回被骗的钱
南昌大学排名
清朝十二帝
北京印刷学院排名
北方工业大学排名
北京航空航天大学排名
首都经济贸易大学排名
中国传媒大学排名
首都师范大学排名
中国地质大学(北京)排名
北京信息科技大学排名
中央民族大学排名
北京舞蹈学院排名
北京电影学院排名
中国戏曲学院排名
河北政法职业学院排名
河北经贸大学排名
天津中德应用技术大学排名
天津医学高等专科学校排名
天津美术学院排名
天津音乐学院排名
天津工业大学排名
北京工业大学耿丹学院排名
北京警察学院排名
天津科技大学排名
北京邮电大学(宏福校区)排名
北京网络职业学院排名
北京大学医学部排名
河北科技大学排名
河北地质大学排名
河北体育学院排名















学习工具


代数计算器


三角函数


解析几何


立体几何






知识解答


教育知识


百科知识


生活知识


常识知识






写作必备


作文大全


作文素材


句子大全



实用范文






关于我们


关于我们


联系我们


网站地图






 交流群

名师互学网交流群




名师互学网客服

名师互学网客服












名师互学网 版权所有 (c)2021-2022      ICP备案号：晋ICP备2021003244-6号
 








我们一直用心在做

关于我们
文章归档
网站地图
联系我们

版权所有 (c)2021-2022 MSHXW.COM


ICP备案号：晋ICP备2021003244-6号