java翻转棋gui单机小游戏

最新推荐文章于 2024-10-16 10:13:45 发布
最新推荐文章于 2024-10-16 10:13:45 发布
阅读量184 收藏 1
点赞数
文章标签： java gui
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43280162/article/details/106943415
版权

BUPT 选修课大作业成果，拿出给大家参考。
没有加注解，多多指教。

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.Date;

public class Reversi extends JFrame{
    JFrame playFrame;
    JPanel jPanel,jPanel01,jPanel02;
    JPanel[] jPanels;
    JLabel jLabel01,jLabel02,jLabel03;
    JButton jButton,jButton02;
    final int gridSide = 80;
    final int chessSide = gridSide - 30;
    int gridNum;
    int clickA = -1, clickB = -1;
    int nowTurn;
    int nowCan;
    int mode;
    int blackNum,whiteNum;
    int[][] nowChess ;
    boolean[][] canChess ;
    MouseListener myMouseListener;

    public Reversi(int modeChoose,int setNum){

        playFrame = this;
        this.setTitle("Reversi");

        mode = modeChoose;
        gridNum = setNum;

        nowChess = new int[gridNum][gridNum];
        canChess = new boolean[gridNum][gridNum];

        FlowLayout frameLayout = new FlowLayout(FlowLayout.CENTER,0,0);
        jPanel = new JPanel(frameLayout);

        jPanel01 = new JPanel(new GridLayout(gridNum, gridNum));
        jPanel02 = new JPanel(new GridLayout(5, 1));
        jLabel01 = new JLabel("Black turn...");
        jLabel02 = new JLabel("Black: 2");
        jLabel03 = new JLabel("White: 2");
        jPanel01.setPreferredSize(new Dimension(gridNum*gridSide, gridNum*gridSide));
        jPanel.add(jPanel01);
        jPanel.add(jPanel02);
        jLabel01.setFont(new Font("微软雅黑", Font.BOLD, 20));
        jLabel02.setFont(new Font("微软雅黑", Font.BOLD, 20));
        jLabel03.setFont(new Font("微软雅黑", Font.BOLD, 20));
        jPanel02.add(jLabel01);
        jPanel02.add(jLabel02);
        jPanel02.add(jLabel03);

        if(mode != 2){
            jButton = new JButton("Robot");
            jPanel02.add(jButton);
            jButton.addActionListener(actionEvent -> autoWait());
        }

        jButton02 = new JButton("Return");
        jPanel02.add(jButton02);
        jButton02.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent actionEvent) {
                playFrame.dispose();
                new StartFrame(8);
            }
        });

        jPanel02.setPreferredSize(new Dimension(gridSide * 2 ,gridNum * gridSide));
        this.add(jPanel);
        initial();
        //draw chess board
        jPanels = new JPanel[gridNum * gridNum];
        for (int i = 0;i < gridNum * gridNum;i++){
            jPanels[i] = new JPanel();
            jPanels[i].setOpaque(true);
            if ((i / gridNum + i % gridNum) % 2 == 1) {
                jPanels[i].setBackground(new Color(	210,105,30));
            }else {
                jPanels[i].setBackground(new Color(244,164,96));
            }
            jPanel01.add(jPanels[i]);
        }

        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        myMouseListener = new MouseListener() {
            @Override
            public void mouseClicked(MouseEvent mouseEvent) {

            }

            @Override
            public void mousePressed(MouseEvent mouseEvent) {
                clickA = mouseEvent.getX()  / gridSide;
                clickB = mouseEvent.getY()  / gridSide;

                validChess();
            }

            @Override
            public void mouseReleased(MouseEvent mouseEvent) {

            }

            @Override
            public void mouseEntered(MouseEvent mouseEvent) {

            }

            @Override
            public void mouseExited(MouseEvent mouseEvent) {

            }
        };
        jPanel01.addMouseListener(myMouseListener);
        this.setResizable(false);
        this.pack();
        this.setVisible(true);

    }

    public void paint(Graphics g){


        super.paint(g);

        for(int i = 0;i < gridNum;i++){
            for(int j = 0;j < gridNum;j++){

                int paintX = i * gridSide + gridSide / 2 - chessSide / 2 + this.getInsets().left;
                int paintY = j * gridSide + gridSide / 2 - chessSide / 2 + this.getInsets().top ;

                if(nowChess[i][j] == 1){
                    g.setColor(Color.BLACK);
                    g.fillOval(paintX,paintY,chessSide,chessSide);
                    continue;
                }

                if(nowChess[i][j] == -1){
                    g.setColor(Color.WHITE);
                    g.fillOval(paintX,paintY,chessSide,chessSide);
                    continue;
                }

                if(canChess[i][j]){
                    g.setColor(new Color(192,192,192,128));
                    g.fillOval(paintX,paintY,chessSide,chessSide);
                }

            }
        }

        if(clickA!=-1){
            int paintA = clickA * gridSide + gridSide / 2 - chessSide / 4 + this.getInsets().left;
            int paintB = clickB * gridSide + gridSide / 2 - chessSide / 4 + this.getInsets().top ;
            g.setColor(new Color(192,192,192,128));
            g.fillOval(paintA,paintB,chessSide / 2,chessSide / 2);
        }

    }

    public void initial(){

        //initialize
        for(int i=0;i<gridNum;i++) {
            for (int j = 0; j < gridNum; j++) {
                nowChess[i][j] = 0;
            }
        }

        nowChess[gridNum/2-1][gridNum/2-1] = 1;
        nowChess[gridNum/2][gridNum/2] = 1;
        nowChess[gridNum/2][gridNum/2-1] = -1;
        nowChess[gridNum/2-1][gridNum/2] = -1;
        nowTurn = 1;

        setCanChess();

    }

    public void changeTurn(){
        nowTurn = - nowTurn;
        switch (nowTurn){
            case 1: jLabel01.setText("Black turn...");
                    break;
            case -1: jLabel01.setText("White turn...");
                    break;
        }
    }

    public void deterTurn(){

        changeTurn();
        setCanChess();

        if(nowCan == 0){
            changeTurn();
            setCanChess();

            if(nowCan == 0){
                countChess();
                this.repaint();
                String[] options ={"Retry","Exit"};
                String content;
                if(blackNum > whiteNum) {content = "Black wins!";}
                else if(blackNum < whiteNum) {content = "White wins!";}
                else {content = "Tie!";}

                int result = JOptionPane.showOptionDialog(this,content,"Game over",
                        JOptionPane.OK_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE, null, options, "Retry");
                switch (result) {
                    case 0:
                        this.dispose();
                        new StartFrame(8);
                        break;
                    case 1:
                        System.exit(0);
                }
            }
        }
    }

    public void validChess(){

        if(canChess[clickA][clickB]){
            nowChess[clickA][clickB] = nowTurn;
            turnChess();
            countChess();
            deterTurn();


            this.repaint();





        }

    }

    public void turnCanChess(int i,int j,int x,int y,int oppoSide,int bias){

        if((i+x<gridNum) && (i+x>-1) && (j+y<gridNum) && (j+y>-1)){

            if(nowChess[i+x][j+y] == -nowTurn){
                bias++;
                turnCanChess(i+x,j+y,x,y,1,bias);
            }

            if((oppoSide == 1) && (nowChess[i+x][j+y] == nowTurn)){

                for(int k=1;k<=bias;k++){
                    nowChess[clickA +k*x][clickB +k*y] = nowTurn;
                }
            }

        }
    }

    public void turnChess(){
        turnCanChess(clickA, clickB,1,0,0,0);
        turnCanChess(clickA, clickB,0,1,0,0);
        turnCanChess(clickA, clickB,-1,0,0,0);
        turnCanChess(clickA, clickB,0,-1,0,0);
        turnCanChess(clickA, clickB,1,1,0,0);
        turnCanChess(clickA, clickB,1,-1,0,0);
        turnCanChess(clickA, clickB,-1,1,0,0);
        turnCanChess(clickA, clickB,-1,-1,0,0);
    }

    public void checkCanChess(int i,int j,int x,int y,int oppoSide,int bias){

        if(canChess[i][j]) return;
        if((i+x<gridNum) && (i+x>-1) && (j+y<gridNum) && (j+y>-1)){

            if(nowChess[i+x][j+y] == -nowTurn){
                bias++;
                checkCanChess(i+x,j+y,x,y,1,bias);
            }

            if((oppoSide == 1) && (nowChess[i+x][j+y] == nowTurn)){
                canChess[i-bias*x][j-bias*y] = true;
                nowCan = 1;
            }

        }
    }

    public void setCanChess(){

        nowCan = 0;
        for(int i=0;i<gridNum;i++) {
            for (int j = 0; j < gridNum; j++) {
            canChess[i][j] = false;
            }
        }

        for(int j=0;j<gridNum;j++) {
            for (int i = 0; i < gridNum; i++) {
                if (nowChess[i][j] == 0) {

                    checkCanChess(i,j,1,0,0,0);
                    checkCanChess(i,j,-1,0,0,0);
                    checkCanChess(i,j,0,1,0,0);
                    checkCanChess(i,j,0,-1,0,0);
                    checkCanChess(i,j,1,1,0,0);
                    checkCanChess(i,j,1,-1,0,0);
                    checkCanChess(i,j,-1,1,0,0);
                    checkCanChess(i,j,-1,-1,0,0);

                }
            }
        }
    }

    public void countChess(){
        blackNum = 0;
        whiteNum = 0;
        for(int i=0;i<gridNum;i++) {
            for (int j = 0; j < gridNum; j++) {
                if(nowChess[i][j] == 1) blackNum++;
                if(nowChess[i][j] == -1) whiteNum++;
            }
        }
        jLabel02.setText("Black: " + blackNum);
        jLabel03.setText("White: " + whiteNum);

    }

    public void autoWait(){
        autoChess();
    }

    public void autoChess(){

        int[][] weight = new int[gridNum][gridNum];
        int chooseA = 0,chooseB = 0;
        int clickA, clickB;

        for(int i=0;i<gridNum;i++) {
            for (int j = 0; j < gridNum; j++) {
                weight[i][j] = 0;
            }
        }

        for(int i=0;i<gridNum;i++) {
            for (int j = 0; j < gridNum; j++) {
                if(!canChess[i][j]){
                    weight[i][j] = -10000000;
                    continue;
                }
                chooseA = i;
                chooseB = j;
                if(   ((i==0)&&(j==0)) || ((i==0)&&(j==7))  || ((i==7)&&(j==0)) || ((i==7)&&(j==7))  ) {
                    weight[i][j] = 1000;
                    continue;
                }

                if(   (i==0) || (i==7) || (j==0) || (j==7)   ) {
                    weight[i][j] = 500;
                    continue;
                }

                if(   ((i==1)&&(j==2)) || ((i==2)&&(j==1))  || ((i==1)&&(j==5)) || ((i==5)&&(j==1)) || ((i==6)&&(j==2)) || ((i==2)&&(j==6))  || ((i==6)&&(j==5)) || ((i==5)&&(j==6)) ) {
                    weight[i][j] = -100;
                    continue;
                }

                if(  ((i==1)&&(j==1)) || ((i==1)&&(j==6))  || ((i==6)&&(j==1)) || ((i==6)&&(j==6))  ) {
                    weight[i][j] = -1000;
                    continue;
                }

                if(   (i==1) || (i==6) || (j==1) || (j==6)   ) {
                    weight[i][j] = -50;
                    continue;
                }

                if(   (i==2) || (i==5) || (j==2) || (j==5)   ) {
                    weight[i][j] = 50;

                }
            }
        }

        for(int i=0;i<gridNum;i++) {
            for (int j = 0; j < gridNum; j++) {
                if(weight[chooseA][chooseB]<weight[i][j]){
                    chooseA = i;
                    chooseB = j;
                }
            }
        }

        clickA = chooseA * gridSide + gridSide / 2;
        clickB = chooseB * gridSide + gridSide / 2;

        long time = new  Date().getTime();

        MouseEvent e = new MouseEvent(jPanel01,501,time, InputEvent.BUTTON1_DOWN_MASK,clickA,clickB,1,false);

        myMouseListener.mousePressed(e);

    }

    public static void main(String[] args){
        new StartFrame(8);
    }
}

class StartFrame extends JFrame{
    int girdNum;
    JFrame jFrameStart;
    JPanel jPanel;
    JButton jButton01,jButton02,jButton03;

    public StartFrame(int setNum){
        jFrameStart = this;
        girdNum = setNum;
        this.setTitle("Reversi-Menu");

        jPanel = new JPanel(new GridLayout(3,1));
        jPanel.setPreferredSize(new Dimension(500,500));
        jButton01 = new JButton("Single Player");
        jButton02 = new JButton("Double Player");
        jButton03 = new JButton("About");
        jPanel.add(jButton02);
        if(girdNum == 8){
            jPanel.add(jButton01);
        }

        jPanel.add(jButton03);
        this.add(jPanel);




        jButton01.addActionListener(actionEvent -> {
            jFrameStart.dispose();
            new Reversi(11,girdNum);
        });

        jButton02.addActionListener(actionEvent -> {
            jFrameStart.dispose();
            new Reversi(2,girdNum);
        });

        jButton03.addActionListener(actionEvent -> {
            jFrameStart.dispose();
            new SettingFrame();
        });

        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.pack();
        this.setVisible(true);
    }
}

class SettingFrame extends JFrame{
    JFrame jFrameSetting;
    JPanel jPanel;
    JPanel jPanel01,jPanel02,jPanel03;
    JButton jButton01;
    JRadioButton jRadioButton01,jRadioButton02,jRadioButton03;
    ButtonGroup buttonGroup;
    JLabel jLabel11,jLabel12,jLabel13,jLabel14,jLabel02;

    public SettingFrame(){
        jFrameSetting = this;
        this.setTitle("Reversi-Setting");

        jPanel = new JPanel(new GridLayout(3,1));
        jPanel.setPreferredSize(new Dimension(500,500));

        GridLayout gridLayout01 = new GridLayout(4,1);

        jPanel01 = new JPanel(gridLayout01);
        jLabel11 = new JLabel("This is a reversi game.");
        jLabel12 = new JLabel("Made by msr");
        jLabel13 = new JLabel("2020.6.13");
        jLabel14 = new JLabel("Version1.0");
        jLabel11.setHorizontalAlignment((int) CENTER_ALIGNMENT);
        jLabel12.setHorizontalAlignment((int) CENTER_ALIGNMENT);
        jLabel13.setHorizontalAlignment((int) CENTER_ALIGNMENT);
        jLabel14.setHorizontalAlignment((int) CENTER_ALIGNMENT);

//        ImageIcon qrc = new ImageIcon("src/qrcode.jpg");
//        qrc.setImage(qrc.getImage().getScaledInstance(150,200,Image.SCALE_DEFAULT));
//        jLabel01.setIcon(qrc);

        jPanel02 = new JPanel();
        jLabel02 = new JLabel("Grid number:");
        jRadioButton01 = new JRadioButton("6");
        jRadioButton02 = new JRadioButton("8");
        jRadioButton03 = new JRadioButton("10");
        buttonGroup = new ButtonGroup();
        buttonGroup.add(jRadioButton01);
        buttonGroup.add(jRadioButton02);
        buttonGroup.add(jRadioButton03);

        jRadioButton02.setSelected(true);

        jPanel03 = new JPanel();
        jButton01 = new JButton("Retrun");
        jButton01.addActionListener(actionEvent -> {
            if(jRadioButton01.isSelected()) new StartFrame(6);
            if(jRadioButton02.isSelected()) new StartFrame(8);
            if(jRadioButton03.isSelected()) new StartFrame(10);

            jFrameSetting.dispose();

        });

        jPanel01.add(jLabel11);
        jPanel01.add(jLabel12);
        jPanel01.add(jLabel13);
        jPanel01.add(jLabel14);
        jPanel02.add(jLabel02);
        jPanel02.add(jRadioButton01);
        jPanel02.add(jRadioButton02);
        jPanel02.add(jRadioButton03);
        jPanel03.add(jButton01);
        jPanel.add(jPanel01);
        jPanel.add(jPanel02);
        jPanel.add(jPanel03);
        jFrameSetting.add(jPanel);

        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.pack();
        this.setVisible(true);
    }
}
weixin_43280162
关注
JAVA之翻转棋游戏
若泣、
03-23 1736
这是我写的另一个小游戏，界面什么的不美观，先来看下效果神马的。 曾经看过一部动漫，叫做秦时明月，里面就有这样一种棋，里面的叫法是墨攻棋局，突然想到，我也就想写写看了，花了些小时写好了这货。。。 看下源码： import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener;
棋子翻转-java
渣渣琪的博客
11-09 840
时间限制：3秒 空间限制：32768K 热度指数：21537 本题知识点： 模拟 编程基础 数组  算法知识视频讲解 题目描述 在4x4的棋盘上摆满了黑白棋子，黑白两色的位置和数目随机其中左上角坐标为(1,1),右下角坐标为(4,4),现在依次有一些翻转操作，要对一些给定支点坐标为中心的上下左右四个棋子的颜色进行翻转，请计算出翻转后的棋盘颜色。 给定两个数组A和f,分
Java经典算法：翻转游戏
阿志同学
03-28 655
您正在和您的朋友一起玩下面的翻转游戏：给定一个仅包含以下两个字符的字符串：+和-，您和您的朋友轮流将两个连续的“ ++”翻转为“-”。当一个人不再能移动时游戏结束，因此另一个人将成为赢家。 编写一个函数，以计算一次有效移动后字符串的所有可能状态。 Java解决方案 public List generatePossibleNextMoves(String s) { List result = new...
翻转棋java实现代码及ai_黑白棋中的 AI
weixin_39603799的博客
03-01 680
到了考试周了佯，可是偏偏这个时候迎来了很多很多的课程设计，幸好教授把C语言的课程设计提前发出了，不然都在最后几周，加上数据结构的课程设计就没有时间做这个啦~刚开始打算做成UWP应用的，可是网上的教程都是C#，并且用C++做的话某些功能和C#不一样，所以就这样拖了好多周，省赛前一点儿也没有开始做，等到省赛结束之后，别人都差不多完成啦！而我才开始准备查找资料……然而一周过去了，进度还是0%。噫，1%吧...
基于java的四国军棋的设计与实现
QQ79856539的博客
03-18 429
随着经济社会的不断进步，当今社会已经进入了竞争的时代。学生们为了学业上的竞争，不得不早起贪黑的学习。为了缓解大家的压力，放松自己的大脑，提高工作学习效率，让生活有松有驰，设计了一个简单的四国军棋游戏。本文所讲述的四国军棋游戏通过人机的竞技，能够开发人们的才干和开发人们的智力。本系统将利用四国军棋游戏作为研究对象，在Windows平台下，运用java语言和Eclipse平台设计的一个能够实现对战的简单游戏。在游戏中可以通过智能的判断使得游戏中的一方获得胜利从而结束游戏，并且通过设置控制对阵双方的游戏时间。
C++十全十美翻转棋小游戏课程设计.zip
04-24
《C++实现翻转棋小游戏课程设计》 在编程领域，C++是一种强大的面向对象的编程语言，广泛应用于系统软件、应用软件、游戏开发以及高性能计算等多个领域。本项目是针对初学者设计的一个C++课程实践，目的是通过实现...
Csharp写的翻转棋游戏.zip
06-18
在这个场景中，我们讨论的是一个使用C#编程语言开发的翻转棋游戏。C#是Microsoft公司推出的一种面向对象的、运行于.NET Framework之上的高级程序设计语言，广泛应用于Windows应用开发、Web开发以及游戏开发等领域。 ...
JAVA手机游戏翻转棋源码
09-24
【JAVA手机游戏翻转棋源码】是一款基于Java语言开发的移动平台游戏，它提供了玩家在手机上体验经典的翻转棋玩法。翻转棋，又称反棋或奥赛罗棋，是一种双人策略游戏，源自19世纪的英国，后来在日本流行并命名为...
C# 翻转棋游戏源程序
07-15
在C#编程环境中开发翻转棋游戏源程序，可以让我们深入了解面向对象编程、图形用户界面（GUI）设计以及算法应用等多个IT知识点。 1. **C#语言基础**：C#是微软公司推出的面向对象的编程语言，广泛应用于Windows平台...
python实现翻转棋游戏（othello）
09-18
【Python实现翻转棋游戏（Othello）】 翻转棋，又称奥赛罗棋，是一种双人对弈策略游戏，玩家通过放置棋子来翻转对手的棋子，最终以拥有最多棋子的一方为胜者。在这个Python实现中，我们将详细探讨如何构建这个游戏...
java实现军旗游戏(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-14 502
java实现军旗游戏(附完整源码)
黑白翻转棋算法java实现_黑白翻转棋算法java实现
weixin_39741459的博客
02-27 978
翻转游戏是在4*4的正方形里进行的，每个小正方形放有拥有黑白两面的棋子。每一轮你翻转3-5个棋子，把它从白变黑或从黑变白。翻转的规则如下： 1. 选择任意一个棋子。 2. 翻转选择的棋子和与它相临的前后左右的棋子(如果有的话)参考如下例子：bwbwwwwwbbwbbwwb其中 b表示黑色在上面，w表示白色在上面。如果选择第三行第一个棋子 进行翻转结果如下：bwbwbwwwwwwbwwwb游戏的目标...
java的socket实现一个九宫棋游戏
一枚菜菜子的充电站
05-14 2520
前言 一个简单的socket小作品=v= 一个机酱在大三实验课中接触到很基础的JAVA语言socket编程。至于你问为什么嵌入式的机酱会弄些Java吗？emmmmm，可能是当初C语言版的不够好玩吧，另外如果碰巧有用，欢迎抱走的yoo 在之前的笔记《网络基础知识和网络编程》中有讲解过关于网络编程的一些基本知识，以及一些LinuxC的socket编程，希望粗浅了解socket内部肌理的同学，右转...
java GUI记忆纸牌游戏(memorize game)
bigsai
03-28 7315
Project制作 首先，一个小程序的制作要考虑的首先是程序界面的布局；其次是算法的设计，实现基本功能；然后再添加其他功能。然后就是Bug以及细节的处理；最后就是制作嵌入帮助开发系统。 一：界面布局篇 1：登陆窗口： 使用的布局管理器：GirdBagLayout(网格组布局管理器也可用Box箱式管理器)，在这个窗口需要对开始游戏和退出设置鼠标监听，如果开始游戏却没输入名字，会弹出请出入...
JAVA记忆翻牌游戏制作
热门推荐
tongyi55555的专栏
06-28 1万+
该游戏主要模拟常见的翻牌游戏，即找到所有两两相同的牌认为游戏成功.
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 222
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 282
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
2024.10月12日--- SpringMVC异常处理
whisper_Java 的博客
10-12 906
*** 用户【】 IP[]* 在【时间】* 操作【Controller.find】 发生如下异常*/@OverrideSystem.out.println("---------执行了自定义异常处理器------------");// 根据不同的异常类型，设置不同的响应状态码// 可以添加更多的自定义处理逻辑//}else {// 记录日志或其他处理逻辑// 可以将异常信息放入模型中供视图展示。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值