Java实现简单的AI五子棋小游戏(一)

最新推荐文章于 2023-02-08 02:06:56 发布
最新推荐文章于 2023-02-08 02:06:56 发布
阅读量785 收藏 9
点赞数 2
分类专栏： Java学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chinahyn/article/details/113814769
版权
本文详细介绍了如何使用Java实现一个五子棋小游戏，包括创建棋盘、监听鼠标点击落子、判断胜负、悔棋功能，以及初步探讨了AI权值算法的实现思路。通过不断优化，游戏不仅能够记录和重绘棋局，还能判断输赢并支持悔棋操作。后续文章将深入讲解如何实现简单的AI对战功能。
摘要由CSDN通过智能技术生成

一、简介：
本程序功能是实现一个简单的AI五子棋小游戏，大致程序模块如下：

  1. 棋盘界面
  2. 鼠标监听器
  3. 按钮监听器
  4. 悔棋功能
  5. AI权值算法

在开始之前，我们先利用接口定义后面经常用上的几个常量：

/*Config.java*/
public interface Config {
	public static final int X1 = 50;    //棋盘起始点的横坐标
    public static final int Y1 = 50;    //棋盘起始点的纵坐标  
    public static final int LINE = 15;  //行数/列数
    public static final int SIZE = 50;  //线间距
    public static final int CHESS = 30; //棋子直径
}                                       //以上单位均为像素

二、画棋盘
画棋盘就要用到JFrame类了，这个类是窗体控件，可以做出GUI程序。编写ChessUI类继承JFrame类即可。

import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JFrame;

public class ChessUI extends JFrame implements Config{
	private static final long serialVersionUID = 1L;
	public ChessUI() {//UI的构造方法
		//窗体的基本组成
		setTitle("五子棋V1.0");
        setSize(800, 800);                       //窗体大小800px*800px
        setDefaultCloseOperation(EXIT_ON_CLOSE); //关闭按钮
        setVisible(true);                        //窗体可视化，将窗体在电脑屏幕上显示
        
	}
	@override
	public void paint(Graphics g) {
		super.paint(g);                 //调用父类方法体内容
		for (int i = 0; i < LINE; i++) {//利用循环逻辑画棋盘线
            g.setColor(Color.black);
            g.drawLine(X1, X1 + SIZE * i, X1 + SIZE * (LINE - 1), Y1 + SIZE * i); 
            g.drawLine(X1 + SIZE * i, X1, Y1 + SIZE * i, Y1 + SIZE * (LINE - 1));
        }
	}
	
	public static void main(String[] args) {
		new ChessUI();//在本类中直接调用构造方法
	}
}
  • 注意：
    这里，棋盘用drawLine方法绘制，并且要重写在paint方法体内，否则，如果在构造方法中画棋盘，窗体界面一旦刷新重绘，棋盘会消失。
  • 运行的结果应该是如下界面：
    初步画好的棋盘

三、实现鼠标点击界面落子（鼠标监听器）

  • 鼠标监听器是干什么的？
    鼠标监听器用来接收鼠标的动作，然后相应的动作会对应实现怎样的功能。
    代码如下，我们以鼠标在窗体中按下时落子：
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

public class ChessListener implements MouseListener,Config{

	public Graphics g = null;//定义一个画笔，用于后面画棋子
	int x , y;               //鼠标点击的点坐标
	
	@Override//鼠标点击时执行的方法
	public void mouseClicked(MouseEvent arg0) {} 

	@Override//鼠标进入组件(窗体)时执行的方法
	public void mouseEntered(MouseEvent arg0) {} 

	@Override//鼠标离开组件时执行的方法
	public void mouseExited(MouseEvent arg0) {} 

	@Override//鼠标按压下去时执行的方法
	public void mousePressed(MouseEvent e) {
		x = e.getX();
		y = e.getY();
		g.setColor(Color.black);                        //设置图形颜色为黑色
		g.fillOval(x-CHESS/2, y-CHESS/2, CHESS, CHESS); //以(x,y)为圆心,CHESS(30px)为直径画圆
	} 
	@Override//鼠标松开时执行的方法
	public void mouseReleased(MouseEvent arg0) {} 
}

效果图如下：
鼠标点击落子
但是，我们的目的是要将棋子下在交叉点处，不能下到交叉点以外对方任何地方，并且要做到黑白交替落子。添加修改后的方法如下：

public void mousePressed(MouseEvent e) {
		x = e.getX();
		y = e.getY();
		//接下来进入坐标校正
		if (x % SIZE < SIZE / 2 && y % SIZE < SIZE / 2) {
            x -= x % SIZE;
            y -= y % SIZE;
        } else if (x % SIZE >= SIZE / 2 && y % SIZE >= SIZE / 2) {
            x = x - x % SIZE + SIZE;
            y = y - y % SIZE + SIZE;
        }
        else if (x % SIZE >= SIZE / 2 && y % SIZE < SIZE / 2) {
            x = x - x % SIZE + SIZE;
            y -= y % SIZE;
        } else if (x % SIZE < SIZE / 2 && y % SIZE >= SIZE / 2) {
            x -= x % SIZE;
            y = y - y % SIZE + SIZE;
        }
        if ((x > X1+SIZE*(LINE-1) || y > Y1+SIZE*(LINE-1))) {     
            return;
        }
        //校正完毕
        if(flag == 1) {
		g.setColor(Color.black);                        //设置图形颜色为黑色
		g.fillOval(x-CHESS/2, y-CHESS/2, CHESS, CHESS); //以(x,y)为圆心,CHESS(30px)为直径画圆
		flag = 2;
        }else if(flag == 2) {
        	g.setColor(Color.white);                        //设置图形颜色为白色
    		g.fillOval(x-CHESS/2, y-CHESS/2, CHESS, CHESS); //以(x,y)为圆心,CHESS(30px)为直径画圆
    		flag = 1;
        }
	}

效果图如下：
在这里插入图片描述
但是这样，窗体界面一旦刷新，棋子就会消失，并且会出现同一点重复落子的情况。为了不让棋子在窗体刷新时候消失，并且要记住哪个点已经落子了以防下次不能再在同一点落子，我们需要用一种存储结构来存储当前棋盘的落子情况。

  • 利用二维数组来储存落子情况
    定义一个chessArray[][]数组，对应棋盘。落黑子的点在数组相应位置标1，白子标2，未落子为0.

继续修改鼠标监听器的方法和paint方法：

	int[][] chessArray = new int[LINE][LINE]; 
	int xx,yy;               //棋盘坐标(xx,yy)的点所下的棋的情况对应元素chessArray[xx][yy]
	                         //这里xx,yy的取值范围是[0,14],代表棋子所在棋盘的列数和行数。
	@Override//鼠标按压下去时执行的方法
	public void mousePressed(MouseEvent e) {
		x = e.getX();
		y = e.getY();
		//接下来进入坐标校正
		if (x % SIZE < SIZE / 2 && y % SIZE < SIZE / 2) {
            x -= x % SIZE;
            y -= y % SIZE;
        } else if (x % SIZE >= SIZE / 2 && y % SIZE >= SIZE / 2) {
            x = x - x % SIZE + SIZE;
            y = y - y % SIZE + SIZE;
        }
        else if (x % SIZE >= SIZE / 2 && y % SIZE < SIZE / 2) {
            x = x - x % SIZE + SIZE;
            y -= y % SIZE;
        } else if (x % SIZE < SIZE / 2 && y % SIZE >= SIZE / 2) {
            x -= x % SIZE;
            y = y - y % SIZE + SIZE;
        }
        if ((x > X1+SIZE*(LINE-1) || y > Y1+SIZE*(LINE-1))) {     
            return;
        }
        //校正完毕
        xx = x / SIZE - 1;
        yy = y / SIZE - 1;
        if(chessArray[xx][yy] != 0) return;             //防止在同一点重复落子
        if(flag == 1) {
		g.setColor(Color.black);                        //设置图形颜色为黑色
		g.fillOval(x-CHESS/2, y-CHESS/2, CHESS, CHESS); //以(x,y)为圆心,CHESS(30px)为直径画圆
		chessArray[xx][yy] = 1;
		flag = 2;
        }else if(flag == 2) {
        	g.setColor(Color.white);                        //设置图形颜色为白色
    		g.fillOval(x-CHESS/2, y-CHESS/2, CHESS, CHESS); //以(x,y)为圆心,CHESS(30px)为直径画圆
    		chessArray[xx][yy] = 2;
    		flag = 1;
        }
	}

再修改paint方法：

public void paint(Graphics g) {
		super.paint(g);
		for (int i = 0; i < LINE; i++) {         //画棋盘线
            g.setColor(Color.black);
            g.drawLine(X1, X1 + SIZE * i, X1 + SIZE * (LINE - 1), Y1 + SIZE * i); 
            g.drawLine(X1 + SIZE * i, X1, Y1 + SIZE * i, Y1 + SIZE * (LINE - 1));
        }
		for(int i = 0;i<LINE;i++) {              //重绘棋子
			for(int j = 0;j<LINE;j++) {
				if(cl.chessArray[i][j] == 1) {
					g.setColor(Color.black);
					g.fillOval((i+1)*SIZE-CHESS/2,(j+1)*SIZE-CHESS/2, CHESS, CHESS);
				} else if(cl.chessArray[i][j] == 2) {
					g.setColor(Color.white);
					g.fillOval((i+1)*SIZE-CHESS/2,(j+1)*SIZE-CHESS/2, CHESS, CHESS);
				}
			}
		}
	}

这样，就实现了棋子的重绘和防止重复落子，后面还可以以此实现判断输赢和AI功能。

四、判断胜负
如何判断胜负？思路是，当前所落子的四个方向直线上至少有一组五子同色连线。
在这里插入图片描述
在最新落下一个白子时，其所在水平方向形成同色五子连线。在一方赢了之后，清空棋盘。代码如下：

@Override//鼠标松开时执行的方法
	public void mouseReleased(MouseEvent e) {
		if(ifWin()) {
			if (chessArray[xx][yy] == 1) {
                JOptionPane.showConfirmDialog(null, "黑方胜利", "游戏结束", JOptionPane.WARNING_MESSAGE);
            }
            else {
                JOptionPane.showConfirmDialog(null, "白方胜利", "游戏结束", JOptionPane.WARNING_MESSAGE);
            }
			clear();
			jf.repaint();
		}
	} 
    private boolean ifWin() {
        if (win1(xx, yy) >= 5 || win2(xx, yy) >= 5 || win3(xx, yy) >= 5 || win4(xx, yy) >= 5) {
            return true;
        }
        else
            return false;
    }

    private int win1(int x, int y) {//横向判断输赢
        int count = 0;
        //向右  
        for (int i = x + 1; i < LINE; i++) {
            if (chessArray[x][y] == chessArray[i][y]&&chessArray[x][y]!=0) {
                count++;
            } else
                break;
        }
        //向左
        for (int i = x; i >= 0; i--) {
            if (chessArray[x][y] == chessArray[i][y]&&chessArray[x][y]!=0) {
                count++;
            } else
                break;
        }
        return count;
    }

    private int win2(int x, int y) {//纵向判断输赢
        int count = 0;
        int i = 0;
        for (i = y + 1; i < LINE; i++) {//向下
            if (chessArray[x][y] == chessArray[x][i] && chessArray[x][y] != 0) {
                count++;
            } else
                break;
        }
            for (i = y; i >= 0; i--) {
                if (chessArray[x][y] == chessArray[x][i] && chessArray[x][y] != 0) {//向上
                    count++;
                } else
                    break;
            }
        return count;
    }

    private int win3(int x, int y) {//主对角线判断
        int count = 0;
        int i = 0, j = 0;
        for (i = x + 1, j = y + 1; i < LINE && j < LINE; i++, j++) {
            if (chessArray[x][y] == chessArray[i][j]&&chessArray[x][y]!=0) {
                count++;
            } else
                break;
        }
        for (i = x, j = y; i >= 0 && j >= 0; i--, j--) {
            if (chessArray[x][y] == chessArray[i][j]&&chessArray[x][y]!=0) {
                count++;
            } else
                break;
        }
        return count;
    }

    private int win4(int x, int y) {//副对角线判别
        int count = 0;
        int i = 0, j = 0;
        for (i = x + 1, j = y - 1; i < LINE && j >= 0; i++, j--) {
            if (chessArray[x][y] == chessArray[i][j]&&chessArray[x][y]!=0) {
                count++;
            } else
                break;
        }
        for (i = x, j = y; i >= 0 && j < LINE; i--, j++) {
            if (chessArray[x][y] == chessArray[i][j]&&chessArray[x][y]!=0) {
                count++;
            } else
                break;
        }
        return count;
    }
    void clear() { //矩阵元素清零

        for (int i = 0; i < LINE; i++) {
            for (int j = 0; j < LINE; j++) {
                chessArray[i][j] = 0;
            }
        }
    }

五、实现悔棋
我们利用栈来储存每一步下棋的横坐标xx和纵坐标yy，如要悔棋，对栈进行pop操作，对pop出的点在二维数组上置零然后重绘一次窗体即可。

class UndoData {  //自定义一个二元组
    int x, y;
}

public class ChessStack implements Config{ //自定义一个栈
    UndoData[] Undo = new UndoData[LINE * LINE];
    int Top = -1;

    public UndoData pop() {
        return Undo[Top--];
    }

    public void push(int x, int y) {
        UndoData ud = new UndoData();
        ud.x = x;
        ud.y = y;
        Undo[++Top] = ud;
    }
}

六、添加按钮功能
我们给窗体添加按钮来实现开始游戏和悔棋的功能 。

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JOptionPane;

//按钮事件监听器,先实现开始游戏和悔棋功能！
public class ButtonListener implements ActionListener{
    public ChessListener cl;
    public ChessUI jf;
    UndoData uData = new UndoData();
    
    Object selectedValue1 = "";
    Object selectedValue2 = "";

	@Override
	public void actionPerformed(ActionEvent e) {
        String btnstr = e.getActionCommand();                  //获取按钮的字符串
        Object[] possibleValues1 = { "PVP" };
        Object[] possibleValues2 = { "黑方先手", "白方先手" };    //设定下拉菜单选项
        switch(btnstr) {
        case "开始/重开" :
        	System.out.println("开始按钮被点击了");
        	if(cl.removeFlag == 1) {
        		jf.removeMouseListener(cl);
        	}
        	cl.clear();
        	jf.repaint();                                      //清空，重绘
        	//设置下拉菜单，获取用户选项
        	selectedValue1 = JOptionPane.showInputDialog(null, "选择对战模式", "提示",
                    JOptionPane.INFORMATION_MESSAGE, null, possibleValues1, possibleValues1[0]);
             
            selectedValue2 = JOptionPane.showInputDialog(null, "选择先后手", "提示",
                    JOptionPane.INFORMATION_MESSAGE, null, possibleValues2, possibleValues2[0]);
            switch((String)selectedValue1) {
            case "PVP":
            	System.out.println("人人对战");
            	jf.addMouseListener(cl);
            	cl.removeFlag = 1;
            default:
            	break;
            }
            switch((String)selectedValue2) {
            case "黑方先手":
            	cl.flag = 1;
                break;
            case "白方先手":
            	cl.flag = 2;
            	break;
            default:
            	break;
            }
            break;
        case "悔棋" :
        	if (cl.cStack.Top == -1) {
                JOptionPane.showMessageDialog(null, "不能再悔棋了!", "提示", JOptionPane.ERROR_MESSAGE);
                break;
            }
            uData = cl.cStack.pop();
            if (cl.chessArray[uData.x][uData.y] == 1) {
                cl.flag = 1;                        //这一步悔了黑子，要重下黑子
            } else if (cl.chessArray[uData.x][uData.y] == 2) {
                cl.flag = 2;                        //这一步悔了白子，要重下白子
            }
            cl.chessArray[uData.x][uData.y] = 0;
            jf.repaint();
            break;
        default:
        	break;
        }
	}
}

相应的，也要在其他类修改方法内容：
在ChessListener类中：

	ChessStack cStack = new ChessStack();    //建立悔棋所用的栈
	int removeFlag = 0;  //拿来判断是否要移除鼠标监听器(防止第一次开始游戏时未add监听器就执行remove)
	
	@Override//鼠标按压下去时执行的方法
	public void mousePressed(MouseEvent e) {
		此处略去获取坐标并校正的方法......
        //校正完毕
        xx = x / SIZE - 1;
        yy = y / SIZE - 1;
        if(chessArray[xx][yy] != 0) return;             //防止在同一点重复落子
        cStack.push(xx, yy);                            //每落一个子，把坐标入栈
        //接下来画棋子
        此处略去画棋子的方法......
        }
	}

在ChessUI类中：

ButtonListener bl = new ButtonListener();
	public ChessUI() {//UI的构造方法
		//窗体的基本组成
		setTitle("五子棋V1.0");
        setSize(1000, 800);
        setDefaultCloseOperation(EXIT_ON_CLOSE); //关闭按钮
        //addMouseListener(cl);                    //给窗体加上鼠标监听器
        setLayout(null);
        JButton btn1 = new JButton("开始/重开");
        JButton btn2 = new JButton("悔棋");
        add(btn1);
        add(btn2);
        btn1.setBounds(800, 100, 150, 40);
        btn2.setBounds(850, 170, 100, 40);       //自定义按钮位置
        setVisible(true);                        //窗体可视化，将窗体在电脑屏幕上显示
        btn1.addActionListener(bl);
        btn2.addActionListener(bl);
        cl.g = getGraphics();                    //把窗体的画笔传给鼠标监听器
        cl.jf = this;
        bl.cl = this.cl;
        bl.jf = this;
	}

这样，我们的五子棋基本功能已经完成！
选择模式，在选择前是无法下棋的
选择先后手
游戏内容
将在(二)中讲述实现简单的AI五子棋功能：
Java实现简单的AI五子棋小游戏(二)
如对此拙作有任何意见或者疑问，欢迎评论或私信提出，批评指正！

空临八荒醉清风
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java实践（十一）——五子棋
涛涌四海向大家学习，与大家携手共进……
11-12 12万+
一、实践目标：       1.掌握JavaGUI界面设计       2.掌握鼠标事件的监听（MouseListener，MouseMotionListener）二、实践内容：      设计一个简单的五子棋程序，能够实现五子棋下棋过程。如下图所示 五子棋运行界面      1.五子棋棋盘类package cn.edu.ouc.fiveChess; import java.awt.Color;
五子棋AI算法 Java实现
热门推荐
KindAzrael的专栏
09-18 1万+
五子棋AI算法 也算是一个典型的游戏AI算法，一些棋类的AI算法都可以参考实现，下面是Java实现代码 棋盘抽象接口 import java.util.List; public interface IChessboard { //取得棋盘最大横坐标 public int getMaxX(); //最大纵坐标 public int getMaxY(); //取得当前所有空白点，
五子棋AI JAVA
03-14
使用JAVA完成的五子棋游戏，Swing做成的界面，人机对弈
JAVA项目-AI五子棋
lwxklts的博客
02-08 314
简单来说，这个项目由两大部分组成，第一部分是界面设置，第二部分是功能实现。
Java版AI五子棋
smile的博客
04-03 4583
去年暑假写的，没什么经验，代码写的那个乱啊！！！ AI思路：通过判断棋盘上每个空位的分数，去分数最高的几个点，随机下棋 分数计算思路：能成5个说明能赢了，给最高分 不能成5个，对方能成5个，说明对方要赢了，给第二高分 能成活4，给第三高分 能成活3，给第四高分 能成冲4，给第五高分 能成冲3，给第六高分 能成活2，给第七高分 能成冲2，给第八高分 其他，给最低分 分数
Java五子棋(含简单AI)
01-23
原来想用博弈树 α-β剪枝法实现人工智能AI，试了2天没测试出来，但代码里有测试的demo已经测试通过，就跟五子棋还没结合起来，网上Java版的博弈树 α-β剪枝法我找不到，虽然最终没有完成，但对于这个算法本身我已经大概知道怎会事儿，算是学习了吧，日后有时间再回来继续完善。
java人工智能五子棋
01-07
Java人工智能五子棋，有兴趣的可以研究一下。可以完美运行！ 机器也有智慧
使用Java实现的简单五子棋小游戏.zip
最新发布
06-15
3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.md文件（如有），仅供学习参考, 切勿用于商业用途。 该资源内项目源码是个人的课程设计，...
Java实现的五子棋小游戏
06-21
这个五子棋小游戏适合以下人群： 初学者：想要学习编写基于Java的简单游戏，并提高他们的编程技能。 爱好者：对五子棋感兴趣，想要在电脑上玩游戏，与电脑进行对战。 教育者：作为教学材料，用于教授Java编程和基本...
java五子棋单机版（附带简单的AI实现）
07-21
java写的单机版五子棋AI版，源码在jar文件内～
Java实现五子棋AI算法
08-27
主要为大家详细介绍了Java实现五子棋AI算法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java实现智能五子棋游戏
01-06
本资源使用Java语言首先实现精美的游戏界面，同时完成了人机对战的功能。经过多次修改已经可以赢大多数人
java简单的五子棋源码-Gomoku-eng:目标是为Gomoku游戏实现人工智能(AI)组件。您必须实现程序的特定部分，根据船上的游戏状态
06-05
java简单的五子棋源码原来的 五木英 目标是为 Gomoku 游戏实现人工智能 (AI) 组件。 您必须实现程序的特定部分，根据船上的游戏状态计算最佳可能的移动。 人工智能必须能够在“合理”水平上执行。 具体要求如下。 在大多数情况下，您的 AI 必须赢得老师提供的 AI（例如 10 分中的 6 分），前提是两者的计算时间都限制为 1 秒。 如果满足以下条件，则保证可解： your program implements minimax algorithm correctly your game status evaluation function is reasonably simple (checks for sets of fices, open fours, half-open fours, open threes) 注意！ 该程序应在 10x10 和 20x20 板上合理运行。 西苏寇德 [peida] 1 Programming in pairs 2 Program framework 3 "auto" botton and benchmark AI 4 Tournamen
Java控制台五子棋小游戏Ai纯算法.zip
01-13
java控制台五子棋，增加了Ai算法 可以选择人机对战 或者人人对战 或者Ai对Ai，没有任何窗口化代码，只有算法代码
AI算法实现五子棋（java）
08-26
主要为大家详细介绍了AI算法实现五子棋，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
用Java实现简单的AI五子棋对弈
Cavendish_key的博客
08-09 696
很基础的实现AI对弈
java 五子棋AI
他山之石 可以攻玉
04-14 270
package wuziqAI; //import jdk.nashorn.internal.scripts.JO; import javax.imageio.ImageIO; import javax.swing.*; import java.awt.*; import java.awt.event.MouseEvent; import java.awt.event.MouseListener; import java.awt.image.BufferedImage; import java.io.Fi.
java五子棋AI
lzq1326253299的博客
08-21 491
五子棋和简单AI的实现： 首先将五子棋的界面写出来。 首先我们写一个接口类，定义好棋盘的数据（目的是方便修改）。 public interface Config { public static final int X0=50;//左上角起点X值 public static final int Y0=50;//左上角起点Y值 public static final in...
人工智能五子棋代码_Java项目实战：五子棋游戏（附带源码和解析）
weixin_32513585的博客
01-23 3324
本节利用二维数组实现五子棋游戏，希望以此来激发大家的编程热情。除此之外，我们还可以利用二维数组来完成连连看、俄罗斯方块、扫雷等常见小游戏。首先定义一个二维数组作为下棋的棋盘，每当一个棋手下一步棋后，也就是为二维数组的一个数组元素赋值。下面代码完成了这个程序的初步功能。import java.util.Scanner;public class Gobang { // 定义棋盘的大小 ...
Java实现五子棋游戏源码示例
在Java编程的世界里，本文档提供了实现一个五子棋游戏的源代码示例。主要涉及以下几个关键知识点： 1. **Java Applet应用**： 这个文档展示了如何使用Java Applet技术来开发一个可嵌入Web页面的应用程序。`...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值