JAVA面向对象编程程序设计——中国象棋

最新推荐文章于 2022-04-30 15:15:18 发布
最新推荐文章于 2022-04-30 15:15:18 发布
阅读量1.4k 收藏 11
点赞数
文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LiGeNb/article/details/122397933
版权

一、团队介绍

连正(队长) | 棋盘的实现，棋子的行动，界面的设计等
王浩天 | 棋局规则(各子的行动限制)，网络对战

二、项目gitee地址

https://gitee.com/immutablelupo/china-chess

三、项目流程图

在这里插入图片描述

四、面向对象设计图

1.实现两方兵的行走规则。

在这里插入图片描述
2.初始化棋盘，其他棋子的行走规则，棋子的选取等。
在这里插入图片描述
3.棋子的坐标。棋子的初始落位。
在这里插入图片描述

4.两个客户端之间的信息处理。
在这里插入图片描述

五、项目关键代码

兵的移动：一次只能移动一格，判断并是否在敌方半场来确定可移动的方向

public static List<Integer[]> bingMove(Chess chess ){
        int i = chess.getI();
        int j = chess.getJ();
        if(chesses[j][i] != chess){
            System.out.println("exp");
        }
        List<Integer[]> list = new ArrayList<>();
        if(Main.colorR.equals(chess.getColor())){
            if(j<5){
                if(j>0){
                    if(chesses[j-1][i] ==null){
                        Integer[] integers = {i,j-1};
                        list.add(integers);
                    }else{
                        if(!chesses[j-1][i].getColor().equals(chess.getColor())){
                            Integer[] integers = {i,j-1};
                            list.add(integers);
                        }
                    }
                }
                if(i>0){
                    if(chesses[j][i-1] ==null){
                        Integer[] integers = {i-1,j};
                        list.add(integers);
                    }else{
                        if(!chesses[j][i-1].getColor().equals(chess.getColor())){
                            Integer[] integers = {i-1,j};
                            list.add(integers);
                        }
                    }
                }
                if(i<9){
                    if(chesses[j][i+1] ==null){
                        Integer[] integers = {i+1,j};
                        list.add(integers);
                    }else{
                        if(!chesses[j][i+1].getColor().equals(chess.getColor())){
                            Integer[] integers = {i+1,j};
                            list.add(integers);
                        }
                    }
                }
            }
        }
        return list;
    }

整个棋盘的实现

public static  void drawPlace(GraphicsContext gc) {
        gc.setLineWidth(3);
        gc.strokeLine(girdW / 3, girdH / 3, girdW / 3, canvasH - girdH / 3);
        gc.strokeLine(girdW / 3 * 2 + girdW * 8, girdH / 3, girdW / 3 * 2 + girdW * 8, canvasH - girdH / 3);
        gc.strokeLine(girdW / 3, girdH / 3 + girdH * 0, canvasW - girdW / 3, girdH / 3 + girdH * 0);
        gc.strokeLine(girdW / 3, girdH / 3 * 2 + girdH * 9, canvasW - girdW / 3, girdH / 3 * 2 + girdH * 9);
        gc.setLineWidth(1);
        //竖线
        for (int i = 0; i < 9; i++) {
            //河界要断开
            if (i == 0 || i == 8) {
                gc.strokeLine(girdW / 2 + girdW * i, girdH / 2, girdW / 2 + girdW * i, canvasH - girdH / 2);
            } else {
                gc.strokeLine(girdW / 2 + girdW * i, girdH / 2, girdW / 2 + girdW * i, canvasH - girdH / 2 - girdH * 5);
                gc.strokeLine(girdW / 2 + girdW * i, canvasH - girdH / 2 - girdH * 4, girdW / 2 + girdW * i, canvasH - girdH / 2);
            }
        }
        //横线
        for (int i = 0; i < 10; i++) {
            gc.strokeLine(girdW / 2, girdH / 2 + girdH * i, canvasW - girdW / 2, girdH / 2 + girdH * i);
        }


        gc.setTextAlign(TextAlignment.CENTER);
        gc.setFont(new Font(fontName, fontSize));
        gc.fillText("楚河              ", girdW / 2 + girdW * 3, canvasH - girdH * 5 + fontSize / 3);
        //画帅的x
        gc.strokeLine(girdW / 2 + girdW * 3, girdH / 2, girdW / 2 + girdW * 5, girdH / 2 + girdH * 2);
        gc.strokeLine(girdW / 2 + girdW * 3, girdH / 2 + girdH * 2, girdW / 2 + girdW * 5, girdH / 2);
        //画将x
        gc.strokeLine(girdW / 2 + girdW * 3, canvasH - girdH / 2, girdW / 2 + girdW * 5, canvasH - girdH / 2 - girdH * 2);
        gc.strokeLine(girdW / 2 + girdW * 3, canvasH - girdH / 2 - girdH * 2, girdW / 2 + girdW * 5, canvasH - girdH / 2);
        //画炮的标
        gc.strokeLine(girdW / 2 + girdW / 3 * 2, girdH / 2 + girdH * 2 - girdH / 10, girdW / 2 + girdW - girdW / 10, girdH / 2 + girdH * 2 - girdH / 10);
        gc.strokeLine(girdW / 2 + girdW / 3 * 2, girdH / 2 + girdH * 2 + girdH / 10, girdW / 2 + girdW - girdW / 10, girdH / 2 + girdH * 2 + girdH / 10);
        gc.strokeLine(girdW / 2 + girdW + girdW / 10, girdH / 2 + girdH * 2 - girdH / 10, girdW / 2 + girdW * 1 + girdW / 3, girdH / 2 + girdH * 2 - girdH / 10);
        gc.strokeLine(girdW / 2 + girdW + girdW / 10, girdH / 2 + girdH * 2 + girdH / 10, girdW / 2 + girdW * 1 + girdW / 3, girdH / 2 + girdH * 2 + girdH / 10);

        gc.strokeLine(girdW / 2 + girdW / 3 * 2, girdH / 2 + girdH * 7 - girdH / 10, girdW / 2 + girdW - girdW / 10, girdH / 2 + girdH * 7 - girdH / 10);
        gc.strokeLine(girdW / 2 + girdW / 3 * 2, girdH / 2 + girdH * 7 + girdH / 10, girdW / 2 + girdW - girdW / 10, girdH / 2 + girdH * 7 + girdH / 10);
        gc.strokeLine(girdW / 2 + girdW + girdW / 10, girdH / 2 + girdH * 7 - girdH / 10, girdW / 2 + girdW * 1 + girdW / 3, girdH / 2 + girdH * 7 - girdH / 10);
        gc.strokeLine(girdW / 2 + girdW + girdW / 10, girdH / 2 + girdH * 7 + girdH / 10, girdW / 2 + girdW * 1 + girdW / 3, girdH / 2 + girdH * 7 + girdH / 10);

        gc.strokeLine(girdW / 2 + girdW / 3 * 2 + girdW * 6, girdH / 2 + girdH * 2 - girdH / 10, girdW / 2 + girdW - girdW / 10 + girdW * 6, girdH / 2 + girdH * 2 - girdH / 10);
        gc.strokeLine(girdW / 2 + girdW / 3 * 2 + girdW * 6, girdH / 2 + girdH * 2 + girdH / 10, girdW / 2 + girdW - girdW / 10 + girdW * 6, girdH / 2 + girdH * 2 + girdH / 10);
        gc.strokeLine(girdW / 2 + girdW + girdW / 10 + girdW * 6, girdH / 2 + girdH * 2 - girdH / 10, girdW / 2 + girdW * 1 + girdW / 3 + girdW * 6, girdH / 2 + girdH * 2 - girdH / 10);
        gc.strokeLine(girdW / 2 + girdW + girdW / 10 + girdW * 6, girdH / 2 + girdH * 2 + girdH / 10, girdW / 2 + girdW * 1 + girdW / 3 + girdW * 6, girdH / 2 + girdH * 2 + girdH / 10);

        gc.strokeLine(girdW / 2 + girdW / 3 * 2 + girdW * 6, girdH / 2 + girdH * 7 - girdH / 10, girdW / 2 + girdW - girdW / 10 + girdW * 6, girdH / 2 + girdH * 7 - girdH / 10);
        gc.strokeLine(girdW / 2 + girdW / 3 * 2 + girdW * 6, girdH / 2 + girdH * 7 + girdH / 10, girdW / 2 + girdW - girdW / 10 + girdW * 6, girdH / 2 + girdH * 7 + girdH / 10);
        gc.strokeLine(girdW / 2 + girdW + girdW / 10 + girdW * 6, girdH / 2 + girdH * 7 - girdH / 10, girdW / 2 + girdW * 1 + girdW / 3 + girdW * 6, girdH / 2 + girdH * 7 - girdH / 10);
        gc.strokeLine(girdW / 2 + girdW + girdW / 10 + girdW * 6, girdH / 2 + girdH * 7 + girdH / 10, girdW / 2 + girdW * 1 + girdW / 3 + girdW * 6, girdH / 2 + girdH * 7 + girdH / 10);

        gc.strokeLine(girdW / 2 + girdW * 1 - girdW / 10, girdH / 2 + girdH * 1 + girdH / 3 * 2, girdW / 2 + girdW * 1 - girdW / 10, girdH / 2 + girdH * 2 - girdH / 10);
        gc.strokeLine(girdW / 2 + girdW * 1 - girdW / 10, girdH / 2 + girdH * 2 + girdH / 10, girdW / 2 + girdW * 1 - girdW / 10, girdH / 2 + girdH * 2 + girdH / 3);
        gc.strokeLine(girdW / 2 + girdW * 1 + girdW / 10, girdH / 2 + girdH * 1 + girdH / 3 * 2, girdW / 2 + girdW * 1 + girdW / 10, girdH / 2 + girdH * 2 - girdH / 10);
        gc.strokeLine(girdW / 2 + girdW * 1 + girdW / 10, girdH / 2 + girdH * 2 + girdH / 10, girdW / 2 + girdW * 1 + girdW / 10, girdH / 2 + girdH * 2 + girdH / 3);

        gc.strokeLine(girdW / 2 + girdW * 1 - girdW / 10, girdH / 2 + girdH * 6 + girdH / 3 * 2, girdW / 2 + girdW * 1 - girdW / 10, girdH / 2 + girdH * 7 - girdH / 10);
        gc.strokeLine(girdW / 2 + girdW * 1 - girdW / 10, girdH / 2 + girdH * 7 + girdH / 10, girdW / 2 + girdW * 1 - girdW / 10, girdH / 2 + girdH * 7 + girdH / 3);
        gc.strokeLine(girdW / 2 + girdW * 1 + girdW / 10, girdH / 2 + girdH * 6 + girdH / 3 * 2, girdW / 2 + girdW * 1 + girdW / 10, girdH / 2 + girdH * 7 - girdH / 10);
        gc.strokeLine(girdW / 2 + girdW * 1 + girdW / 10, girdH / 2 + girdH * 7 + girdH / 10, girdW / 2 + girdW * 1 + girdW / 10, girdH / 2 + girdH * 7 + girdH / 3);


        gc.strokeLine(girdW / 2 + girdW * 7 - girdW / 10, girdH / 2 + girdH * 1 + girdH / 3 * 2, girdW / 2 + girdW * 7 - girdW / 10, girdH / 2 + girdH * 2 - girdH / 10);
        gc.strokeLine(girdW / 2 + girdW * 7 - girdW / 10, girdH / 2 + girdH * 2 + girdH / 10, girdW / 2 + girdW * 7 - girdW / 10, girdH / 2 + girdH * 2 + girdH / 3);
        gc.strokeLine(girdW / 2 + girdW * 7 + girdW / 10, girdH / 2 + girdH * 1 + girdH / 3 * 2, girdW / 2 + girdW * 7 + girdW / 10, girdH / 2 + girdH * 2 - girdH / 10);
        gc.strokeLine(girdW / 2 + girdW * 7 + girdW / 10, girdH / 2 + girdH * 2 + girdH / 10, girdW / 2 + girdW * 7 + girdW / 10, girdH / 2 + girdH * 2 + girdH / 3);

        gc.strokeLine(girdW / 2 + girdW * 7 - girdW / 10, girdH / 2 + girdH * 6 + girdH / 3 * 2, girdW / 2 + girdW * 7 - girdW / 10, girdH / 2 + girdH * 7 - girdH / 10);
        gc.strokeLine(girdW / 2 + girdW * 7 - girdW / 10, girdH / 2 + girdH * 7 + girdH / 10, girdW / 2 + girdW * 7 - girdW / 10, girdH / 2 + girdH * 7 + girdH / 3);
        gc.strokeLine(girdW / 2 + girdW * 7 + girdW / 10, girdH / 2 + girdH * 6 + girdH / 3 * 2, girdW / 2 + girdW * 7 + girdW / 10, girdH / 2 + girdH * 7 - girdH / 10);
        gc.strokeLine(girdW / 2 + girdW * 7 + girdW / 10, girdH / 2 + girdH * 7 + girdH / 10, girdW / 2 + girdW * 7 + girdW / 10, girdH / 2 + girdH * 7 + girdH / 3);
    }

棋子移动时触发的“吃”，和胜利的判定

 public void PlayChess(int i,int j, GraphicsContext gc)
    {


        Chess chess = CanvasUtils.clickChess(i*girdW,j*girdH);

        if(chess != null)
        {
            if(selectChess == null )
            {
                if(chess.getColor().equals("R")&&roundchange==0||chess.getColor().equals("B")&&roundchange==1)
                {
                    {
                        if(roundchange==0)
                        {
                            roundchange = roundchange + 1;
                        }
                        else if(roundchange==1)
                        {
                            roundchange = roundchange - 1;
                        }
                        System.out.println(roundchange);
                        CanvasUtils.selectChess(chess, gc);

                    }
                }
            }
            else
            {

                CanvasUtils.moveChess(i, j, gc);//吃棋子
                if(Tool!=null) {
                    if (Tool.chessName.equals("帥") || Tool.chessName.equals("將"))
                        System.out.println("win!");
                }

            }
        }
        else
        {

            CanvasUtils.moveChess(i, j, gc);//移动到没有棋子的地方
            if(Tool!=null) {
                if (Tool.chessName.equals("帥") || Tool.chessName.equals("將"))
                    System.out.println("win!");
            }
        }
    }

服务器，读取并转发客户端送来的信息。

public class Server {

    ServerSocket serverSocket = null;
    static Map<Integer, Socket> map = new HashMap<Integer, Socket>();
    public static int i=1;
    public static int flag3=0;
    public static BufferedWriter bwa = null;
    public static BufferedWriter bwb = null;

    public void socket() throws IOException {
        try {

            ServerSocket ss = new ServerSocket(8887);
            System.out.println("启动服务器....");
            //客户端1
            ExecutorService executor= Executors.newFixedThreadPool(1);
            CompletableFuture<String> future2 = CompletableFuture.supplyAsync(()-> {
                try {


                    System.out.println("异步启动:");

                    try {
                        while(true) {
                            Socket s1 = ss.accept();
                            InetAddress inetAddress=s1.getInetAddress();
                            System.out.println("客户端:" +"2:"+ s1.getInetAddress().getLocalHost() + "已连接到服务器");
                            flag3++;
                            i++;
                            System.out.println(i);
                            if (s1 != null) {

                                try {
                                    while(true) {
                                        // 3.获取socket通道的输入流(输入流的读取方式为一行一行的读取方式 ----> readLine())

                                        // 4.获取通道的输入流(也是一行一行的写出  BufferedWriter ->newLine())
                                        // 当用户点击“发送”按钮的时候才会，写出数据
                                        BufferedReader br1 = new BufferedReader(new InputStreamReader(s1.getInputStream()));
                                        Server.bwb = new BufferedWriter(new OutputStreamWriter(s1.getOutputStream()));
                                        if(flag3==2)
                                        {
                                            String line1="双方棋手已就位,请红色方先开始棋局";
                                            bwa.write(line1);
                                            System.out.println("服务端发送信息:"+line1);
                                            bwa.newLine(); // 换行
                                            bwa.flush();  //

                                            bwb.write(line1);
                                            System.out.println("服务端发送信息:"+line1);
                                            bwb.newLine(); // 换行
                                            bwb.flush();  //

                                        }
                                        String line = null;
                                        while ((line = br1.readLine()) != null) {
                                            System.out.println("客户端发送信息:" + line);
                                            // 将读取的数据拼接到文本域中显示
                                            if (line.contains("#")) {
                                                bwa.write(line);
                                                System.out.println("服务端发送信息:"+line);
                                                bwa.newLine(); // 换行
                                                bwa.flush();  //

                                            }
                                        }
                                        System.out.println(line);
                                    }


                                } catch(Exception e){
                                    e.printStackTrace();
                                }
                            }
                        }

                    } catch (IOException e) {
                        e.printStackTrace();
                    }


                    Thread.sleep(5000);
                    return "finish";
                } catch (InterruptedException e) {
                    System.err.println("错误！");
                    return "wrong！";
                }
            },executor);
            //客户端2
                    while (true) {
                        Socket s2 = ss.accept();
                        InetAddress inetAddress = s2.getInetAddress();
                        System.out.println("客户端:" + "1:" + s2.getInetAddress().getLocalHost() + "已连接到服务器");
                        flag3++;
                        if (s2 != null) {

                            try {
                                while (true)
                                {
                                    // 3.获取socket通道的输入流(输入流的读取方式为一行一行的读取方式 ----> readLine())

                                    // 4.获取通道的输入流(也是一行一行的写出  BufferedWriter ->newLine())
                                    // 当用户点击“发送”按钮的时候才会，写出数据
                                    BufferedReader br1 = new BufferedReader(new InputStreamReader(s2.getInputStream()));
                                Server.bwa = new BufferedWriter(new OutputStreamWriter(s2.getOutputStream()));
                                    if(flag3==2)
                                    {
                                        String line1="双方棋手已就位,请红色方开始棋局";
                                        bwa.write(line1);
                                        System.out.println("服务端发送信息:"+line1);
                                        bwa.newLine(); // 换行
                                        bwa.flush();  //

                                        bwb.write(line1);
                                        System.out.println("服务端发送信息:"+line1);
                                        bwb.newLine(); // 换行
                                        bwb.flush();  //

                                    }
                                String line = null;
                                while ((line = br1.readLine()) != null) {
                                    System.out.println("客户端发送信息:" + line);
                                    // 将读取的数据拼接到文本域中显示
                                        bwb.write(line);
                                        System.out.println("服务端发送信息:"+line);
                                        bwb.newLine(); // 换行
                                        bwb.flush();  //
                                }
                                System.out.println(line);
                            }


                            } catch (Exception e) {
                                e.printStackTrace();
                            }


                        }
                    }



        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) throws IOException {
        new Server().socket();
    }
}

七、客户端发送信息

public void sendServer(String msg)
    {
        try {
            bw1.write(msg);
            bw1.newLine(); // 换行
            bw1.flush();  //
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

八、客户端接收信息

btn.setOnAction(actionEvent -> {

            ExecutorService executor= Executors.newFixedThreadPool(1);
            CompletableFuture<String> future2 = CompletableFuture.supplyAsync(()-> {
                try {

                    try{
                        /*******客户端 TCP协议*********/
                        // 1.创建一个客户端的套接字（尝试连接）
                        Socket socket = new Socket("127.0.0.1",8887);

                        // 2.获取socket通道的输入流
                        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));


                        bw1 = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

                        String line = null;
                        while((line = br.readLine()) !=null)
                        {

                            textarea.appendText("服务器发送信息:"+line);

                            if(line.contains("#"))
                            {
                                String ti=String.valueOf(line.charAt(1));
                                String tj=String.valueOf(line.charAt(2));
                                String ta=String.valueOf(line.charAt(3));
                                String tb=String.valueOf(line.charAt(4));
                                System.out.println(ti+tj+ta+tb);
                                updateChess(Integer.parseInt(ta),Integer.parseInt(tb),Integer.parseInt(ti),Integer.parseInt(tj),gc);
                                textarea.appendText("对方落子:"+line.substring(1,3)+"-->"+line.substring(3,5));
                                stop=0;
                                if(roundchange==1)
                                {
                                    roundchange = roundchange - 1;
                                }
                                else if(roundchange==0)
                                {
                                    roundchange=roundchange+1;
                                }

                            }
                          if(line.contains("@"))
                            {
                                textarea.appendText(line);
                            }

                        }
                        System.out.println(line);
                        // 3. 获取输出流

                        // 4.关闭流
                        socket.close();

                        /******************************/
                    }
                    catch(Exception e){
                        e.printStackTrace();
                    }

                    Thread.sleep(5000);
                    return "finish";



                } catch (InterruptedException e) {
                    System.err.println("错误！");
                    return "wrong！";
                }
            },executor);




        });

六、运行截图

单机版的运行
在这里插入图片描述
网络对战版
在这里插入图片描述
两者连接
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

七、尚待改进

1.象棋走棋提示不是很完善，登陆系统也没有实现；
2.课设虽然很早已经开始让我们考虑，由于其他学科和考试等原因在计网课设之后才开始，时间太短界面过于简陋。

象棋 Java设计（java课程设计）计算机科学与技术
weixin_51548958的博客
06-22 4536
文章目录 系列文章目录 前言 一、象棋的整个程序的架框 二、棋盘界面的java设计 三、棋盘规则所使用代码 四、功能测试 五、棋盘界面的测试 总结 前言 结合JAVA和中国象棋方面的实践经验，在分析了中国象棋游戏需求基础上，设计并实现了中国象棋系统。该系统为人人对战。人人对战规则明确，包含了中国象棋所有的招法。方便了不同水平人群的不同选择。设计和开发好中国象棋游戏，对与提高Java开发水平和系统的设计能力有极大的帮助。 主要研究基于JAVA技术的中...
国际象棋棋盘 java_java绘制国际象棋与中国象棋棋盘
weixin_35790607的博客
02-12 627
JAVA API 中的绘制图形类的paint()方法，我们可以轻松绘制中国象棋与国际象棋的棋盘。详见代码：一、中国象棋棋盘代码import java.awt.Font;import java.awt.Frame;import java.awt.Graphics;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent...
中国象棋程序的设计与实现(原始版)(包含源码)
09-09
2010年，我从CSDN下载中心下载了1个中国象棋程序，功能比较简单。 我在此基础上，开发了当前版本(1.0)的程序。相对于下载的版本， 增加了联网对战，悔棋等功能，增加必要的注释，重命名类、函数、变量的名字，提高了可读性。 特别说明：这个1.0版本的功能比较弱，用户体验也很差，bug也不少。 主要用来学习用，如果有兴趣，可以自行完善。 敬请期待：2.0版本比1.0版本要好很多，无论是功能还是用户体验，近期更新，敬请期待。
中国象棋java版
07-25
中国象棋java版demo，需要的就下载吧，代码导入启动就可以用了
中国象棋源代码(Java)
11-20
Java版的中国象棋源代码，如果感兴趣的可以自己研究下
JAVA 实现《中国象棋》游戏-全部源码
02-05
# 主要设计 1、寻找棋盘界面和对应的棋子图片，程序设计棋盘界面和功能菜单 2、设计不同的棋子的移动逻辑 3、棋子移动时，要有音效 4、设计对手AI的逻辑算法，这里运用了极大极小值搜索算法，设置不同的搜索深度AI(智能不同) 5、对局开始前，双方棋子在棋盘上的摆法。 6、对局时，由执红棋的一方先走，双方轮流走一步。 7、轮到走棋的一方，将某个棋子从一个交叉点走到另一个交叉点，或者吃掉对方的棋子而占领其交叉点，都算走了一着。 8、双方各走一着，称为一个回合。 9、走一着棋时，如果己方棋子能够走到的位置有对方棋子存在，就可以把对方棋子吃掉而占领那个位置。 10、一方的棋子攻击对方的帅（将），并在下一着要把它吃掉，称为“照将”，或简称“将”。“照将”不必声明。被“照将”的一方必须立即“应将”，即用自己的着法去化解被“将”的状态。如果被“照将”而无法“应将”，就算被“将死”。 11、特别设计了人机对弈，人人对弈，还有AI对AI对弈 需要技术指导，写项目程序，等更多服务请加微信xiaoxuzhu01联系博主
使用java编写中国象棋（内含源代码）
weixin_43653841的博客
12-09 1274
中国象棋，包含用纯java写的，也有在线联机版的。全部开源可用
Java小游戏象棋开发1-界面设计
m0_63248617的博客
04-30 3179
象棋系统1页面设计
Java象棋代码
06-27
一款优秀的Java象棋代码，下载之后解压导入即可，基于Java的图形界面
JAVA课程设计——中国象棋java源代码
05-04
首先，我们需要了解Java的基础语法和面向对象编程的概念。在Java中，类是程序的基本构造块，每个对象都有其特定的属性和行为。在设计中国象棋游戏时，我们可能会创建棋盘类、棋子类、玩家类等。例如，棋盘类负责存储...
象棋游戏java代码
07-15
此代码是利用java开发的象棋游戏代码，充分利用了java的多线程技术和通讯对象
java实现象棋
06-06
基于java实现参考一下的象棋小游戏，是我学习java来练练手的，java基础入门的学生可以考虑
中国象棋（java）
06-27
一个很好的教学源码，很经典的游戏开发学习例子，实现了核心的代码，没有网络模块，但是数据定义支持网络对战的扩展。可以直接运行。
Java版象棋（源代码）
01-17
Java版象棋，含源代码和图标 import java.awt.*; import java.awt.event.*; import javax.swing.*; import java.util.*; import java.io.*;
JAVA程序代码——中国象棋
12-22
1. **面向对象设计**：中国象棋中的每颗棋子都有其独特的移动规则和行为，这非常适合使用面向对象编程来实现。每个棋子可以被抽象为一个类，如“兵”（Pawn）、“車”（Rook）、“馬”（Knight）等，每个类封装其...
中国象棋游戏源码.rar
04-26
总的来说，"中国象棋游戏源码"是一个丰富的学习资源，涵盖了Java语言基础、面向对象编程、游戏逻辑设计、图形用户界面等多个方面。通过深入学习和实践，不仅可以掌握编程技术，还能培养解决问题和独立思考的能力，...
利用java编写的中国象棋游戏.zip
最新发布
12-17
总之，"利用Java编写的中国象棋游戏"项目涵盖了从基础编程到高级设计模式的诸多知识，对于提升Java编程技能，理解和实践面向对象设计原则，以及了解游戏开发流程具有极大的价值。无论是初学者还是经验丰富的开发者，...
精品资料（2021-2022年收藏）中国象棋棋谱设计Java课程设计实验报告分析.doc
10-10
总之，这份报告详细展示了如何使用Java Swing库进行图形用户界面的开发，以及如何利用面向对象编程设计一个功能完善的中国象棋应用。通过这样的课程设计，学生能够获得实际的编程经验，巩固理论知识，并提升问题解决...
Java实现中国象棋程序设计
1. **Java程序设计**：报告中指出，中国象棋软件的开发是使用Java编程语言进行的，这表明了Java在构建复杂系统时的灵活性和跨平台特性。 2. **位棋盘(BitBoard)**：在引擎包(engine)中，位棋盘是一种高效的数据结构...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值