Java 版炸金花

最新推荐文章于 2023-09-25 15:28:18 发布
最新推荐文章于 2023-09-25 15:28:18 发布
阅读量3.3k 收藏 33
点赞数 7
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44773719/article/details/102834417
版权

一：需求分析：
游戏分为 5 类牌：
1：豹子 ：三张牌点数一样
2：顺子：三张牌点数连续
3：清一色：三张牌花色相同
4：对子：三张牌中有两张牌点数相同
5：单张：除去上述的 4 种情况
规则：我们把大小规则定为：豹子 > 顺子 > 清一色 > 对子 > 单张. 如果玩家牌的类型相同，就依次比较最大牌的点数。

二：代码设计：
1.首先设计一个 Pai 的类，用来表示每一张牌的花色和点数。
2.构造完一副牌后，再洗牌，在这里我们可以用库中的洗牌的方法—> Collections.shuffle()，也可以自己写一个洗牌方法。
3.我们假定有三个玩家，再给玩家发牌，每人发三张。
4.比较大小得出最大的玩家。

三：代码具体实现

1.Pai 类：用来描述每张牌的点数和花色，此外还重写了 toString 方法

//创建卡牌类

class Pai {
    protected String suit; //花色
    protected String count; //点数

    public Pai(String suit, String count) {
        this.suit = suit;
        this.count = count;
    }

    @Override
    public String toString() {
        return "(" + suit + count + ")";
    }
}

2.函数主体包含了 4 部分：
（1）构造一副牌 （2）洗牌 （3）发牌 （4）比大小

（1）构造一副牌：点数我们用字符串表示，外层循环表示牌的花色，内层循环表示牌的点数，
在内层循环下表示出 J、Q、K、A。

 private final static String[] SUITS = {"♥️","♠️","♦️","♣️"};
    public static List<Pai> buyCard() {
        List<Pai> poker = new ArrayList<>();
        for (int i = 0; i < 4; i++) {
            for (int j = 2; j <= 10; j++) {
                poker.add(new Pai(SUITS[i], j + ""));
            }
            poker.add(new Pai(SUITS[i], "J"));
            poker.add(new Pai(SUITS[i], "Q"));
            poker.add(new Pai(SUITS[i], "K"));
            poker.add(new Pai(SUITS[i], "A"));
        }
        return poker;
    }

（2）洗牌：我们用的方法是：从后往前遍历 List ，每次取到一个元素的时候再产生一个随机数，然后把当前取到的元素和随机数交换，
再取到下一个元素，再产生一个随机数，再交换……
此外，我们还可以用库函数中的 Collections.shuffle() 方法进行洗牌。

   public static void XiPai(List<Pai> list) {
        Random random = new Random();
        for (int i = list.size() - 1; i >= 0; i--) {
             int ret = random.nextInt(list.size());
             Pai tmp = list.get(i);
             list.set(i,list.get(ret));
             list.set(ret,tmp);
        }
    }

（3）发牌：因为每个玩家要手握三张牌，所以每一个玩家都是一个牌的集合，因此 players 里面是 List 的集合。
在发牌时，我们先得到某一个玩家，再增加这个玩家手中的牌，我们每次把这副牌中的第一张发给这个玩家，同时在这副牌中删除这张牌，
然后再发牌时再从第一张发。最后打印三个玩家手中的牌。

 List<List<Pai>> players = new ArrayList<>();
    //三个玩家
    players.add(new ArrayList<Pai>());
    players.add(new ArrayList<Pai>());
    players.add(new ArrayList<Pai>());
    for (int playerIndex = 0; playerIndex < 3; playerIndex++) {
        for (int cardIndex = 0; cardIndex < 3; cardIndex++) {
            players.get(playerIndex).add(poker.remove(0));
        }
    }
    System.out.println("玩家1：");
    System.out.println(players.get(0));
    System.out.println("玩家2：");
    System.out.println(players.get(1));
    System.out.println("玩家3：");
    System.out.println(players.get(2));

（4）比大小：
首先，豹子就是比较三张牌的点数；顺子就是比较三张牌的花色；对子就是任意两张牌的点数相同；单张就是三张牌的点数跟花色都不相同。唯独顺子比较麻烦。在这里我们的解决方法是：先对玩家手中的三张牌进行降序排序，然后比较前后两张牌的点数差值是否是 1 即可。
在比较时，我们采用不同的权重来区别牌的类别以及牌中不同点数顺序。
比如：首先根据牌的类型先给出一个值（当然这个值比较大，为牌的类型直接决定牌的大小），如果玩家牌的类型相同在比较牌的点数（此处三张牌的权重也不相同，因为如果最大的牌比较出来了，后面的牌就不用比较了，因此三张牌按照大小顺序的权重也不同），我们必须保证后面牌的权重值的和不能大于牌的类型的值和前面较大牌的值。
注：豹子给定的值：5000 ； 顺子给定的值： 4000 ； 清一色给定的值： 3000 ； 对子给定的值： 2000； 单张给定的值： 1000 ；
三张牌按照大小顺序给定的权重： * 1000 ； *10 ； *1 。

排序方法：为了方便比较大小，我们把10，J，Q，K，A的值根据 asc|| 转化成与 1 ~ 9 连续的值了。

private static void swap(String[] arr) {
        String max1 = "";
        String max2 = "";
        String max3 = "";
        for (int i = 0; i < 3; i++) {
            if (arr[i].equals("10")) {
                arr[i] = ":";
            }
            if (arr[i].equals("J")) {
                arr[i] = ";";
            }
            if (arr[i].equals("Q")) {
                arr[i] = "<";
            }
            if (arr[i].equals("K")) {
                arr[i] = "=";
            }
            if (arr[i].equals("A")) {
                arr[i] = ">";
            }
        }
        if (arr[0].compareTo(arr[1]) > 0) {
            max2 = arr[0];
            max3 = arr[1];
            if (arr[2].compareTo(max2) > 0) {
                max1 = arr[2];
            } else if (arr[2].compareTo(max2) < 0){
                max1 = max2;
                if (arr[2].compareTo(max3) > 0) {
                    max2 = arr[2];
                } else {
                    max2 = max3;
                    max3 = arr[2];
                }
            } else {
                max1 = arr[2];
            }
        } else if(arr[0].compareTo(arr[1]) < 0){
            max2 = arr[1];
            max3 = arr[0];
            if (arr[2].compareTo(max2) > 0) {
                max1 = arr[2];
            } else if (arr[2].compareTo(max2) < 0) {
                max1 = max2;
                if (arr[2].compareTo(max3) > 0) {
                    max2 = arr[2];
                } else {
                    max2 = max3;
                    max3 = arr[2];
                }
            } else {
                max1 = arr[2];
            }
        } else if (arr[0].compareTo(arr[1]) == 0) {
            if (arr[2].compareTo(arr[1]) == 0) {
                max1 = arr[0];
                max2 = arr[0];
                max3 = arr[0];
            } else if (arr[2].compareTo(arr[1]) > 0) {
                max1 = arr[2];
                max2 = arr[1];
                max3 = arr[0];
            } else {
                max3 = arr[2];
                max2 = arr[0];
                max1 = arr[1];
            }
            arr[0] = max1;
            arr[1] = max2;
            arr[2] = max3;
            return;
        }
        arr[0] = max1;
        arr[1] = max2;
        arr[2] = max3;
        return;
    }

根据玩家牌的类型和大小设置成具体的数值，存放在三个数组中：我们根据牌点数的不同设定了不同的大小，最后在乘上该值的权重，当然在比较大小前玩家手中的牌我们已将按照降序排好顺序了。

 private static float compaire(String[] arr) {
        float[] ret = new float[3];
       for (int i = 0; i < 3; i++) {
           if (arr[i] == ">") {
               ret[i] = 0.13f;
           } else if (arr[i] == "=") {
               ret[i] = 0.12f;
           } else if (arr[i] == "<") {
               ret[i] = 0.11f;
           } else if (arr[i] == ";") {
               ret[i] = 0.10f;
           } else if (arr[i] == ":") {
               ret[i] = 0.09f;
           } else if (arr[i] == "9") {
               ret[i] = 0.08f;
           } else if (arr[i] == "8") {
               ret[i] = 0.07f;
           } else if (arr[i] == "7") {
               ret[i] = 0.06f;
           } else if (arr[i] == "6") {
               ret[i] = 0.05f;
           } else if (arr[i] == "5") {
               ret[i] = 0.04f;
           } else if (arr[i] == "4") {
               ret[i] = 0.03f;
           } else if (arr[i] == "3") {
               ret[i] = 0.02f;
           } else if (arr[i] == "2") {
               ret[i] = 0.01f;
           }
           if (i == 0) {
               ret[i] *= 1000;
           } else if (i == 1) {
               ret[i] *= 10;
           } else {
               ret[i] *= 1;
           }
       }
       return ret[0] + ret[1] + ret[2];
    }

具体的比较方法：根据数组中算出的三个玩家牌的大小进行排序.

 public static void match(List<List<Pai>> players) {
        float[] player = new float[3];
        String[] arr1 = {players.get(0).get(0).count,players.get(0).get(1).count,
                players.get(0).get(2).count};
        String[] arr2 = {players.get(1).get(0).count,players.get(1).get(1).count,
                players.get(1).get(2).count};
        String[] arr3 = {players.get(2).get(0).count,players.get(2).get(1).count,
                players.get(2).get(2).count};
        swap(arr1);
        swap(arr2);
        swap(arr3);
        String[][] cur = {arr1,arr2,arr3};
        for (int i = 0; i < 3; i++) {
            if (cur[i][0].equals(cur[i][1]) && cur[i][0].equals(cur[i][2])) {
                player[i] = 5000.0f;
                player[i] += compaire(cur[i]);
            } else if (cur[i][0].compareTo(cur[i][1]) == 1 && cur[i][1].compareTo(cur[i][2]) == 1) {
                player[i] = 4000.0f;
                player[i] += compaire(cur[i]);
            } else if (players.get(i).get(0).suit.equals(players.get(i).get(1).suit)
                    && players.get(i).get(0).suit.equals(players.get(i).get(2).suit)) {
                player[i] = 3000.0f;
                player[i] += compaire(cur[i]);
            } else if (cur[i][0].equals(cur[i][1]) || cur[i][0].equals(cur[i][2]) || cur[i][1].equals(cur[i][2])) {
                player[i] = 2000.0f;
                player[i] += compaire(cur[i]);
            } else if (cur[i][0].compareTo(cur[i][1]) != 0 && cur[i][0].compareTo(cur[i][2]) != 0
                    && cur[i][1].compareTo(cur[i][2]) != 0 ) {
                player[i] = 1000.0f;
                player[i] += compaire(cur[i]);
            }
        }
        float max = -1;
        int flag = -1;
        int flag2 = -1;
        int flag3 = -1;
        for (int i = 0; i < 3; i++) {
            if (player[0] == player[1] && player[0] == player[2]) {
                flag3 = 0;
            }
            if (player[i] > max) {
                max = player[i];
                flag = i + 1;
            } else if (player[i] == max) {
                flag2 = i + 1;
            }
        }
        if (flag2 != -1 && flag3 == -1) {
            System.out.println("玩家" + flag + "和" + flag2 + "的牌一样大");
        } else if (flag3 != -1) {
            System.out.println("三个玩家的牌一样大");
        }
        System.out.println("玩家" + flag + "的牌最大");
    }

最终完整的代码如下：

//创建卡牌类
class Pai {
    protected String suit; //花色
    protected String count; //点数

    public Pai(String suit, String count) {
        this.suit = suit;
        this.count = count;
    }

    @Override
    public String toString() {
        return "(" + suit + count + ")";
    }
}

public class KaPai {
    public static void main(String[] args) {
        //1.构造一副牌
        List<Pai> poker = buyCard();
        //2.洗牌
        //Collections.shuffle(poker);
        XiPai(poker);
        System.out.println(poker);
        //3.分牌
        List<List<Pai>> players = new ArrayList<>();
        //三个玩家
        players.add(new ArrayList<Pai>());
        players.add(new ArrayList<Pai>());
        players.add(new ArrayList<Pai>());
        for (int playerIndex = 0; playerIndex < 3; playerIndex++) {
            for (int cardIndex = 0; cardIndex < 3; cardIndex++) {
                players.get(playerIndex).add(poker.remove(0));
            }
        }
        System.out.println("玩家1：");
        System.out.println(players.get(0));
        System.out.println("玩家2：");
        System.out.println(players.get(1));
        System.out.println("玩家3：");
        System.out.println(players.get(2));
        //4.比大小
        match(players);
    }
    private final static String[] SUITS = {"♥️","♠️","♦️","♣️"};
    public static List<Pai> buyCard() {
        List<Pai> poker = new ArrayList<>();
        for (int i = 0; i < 4; i++) {
            for (int j = 2; j <= 10; j++) {
                poker.add(new Pai(SUITS[i], j + ""));
            }
            poker.add(new Pai(SUITS[i], "J"));
            poker.add(new Pai(SUITS[i], "Q"));
            poker.add(new Pai(SUITS[i], "K"));
            poker.add(new Pai(SUITS[i], "A"));
        }
        return poker;
    }
    //洗牌
    public static void XiPai(List<Pai> list) {
        Random random = new Random();
        for (int i = list.size() - 1; i >= 0; i--) {
             int ret = random.nextInt(list.size());
             Pai tmp = list.get(i);
             list.set(i,list.get(ret));
             list.set(ret,tmp);
        }
    }
    //比大小
    public static void match(List<List<Pai>> players) {
        float[] player = new float[3];
        String[] arr1 = {players.get(0).get(0).count,players.get(0).get(1).count,
                players.get(0).get(2).count};
        String[] arr2 = {players.get(1).get(0).count,players.get(1).get(1).count,
                players.get(1).get(2).count};
        String[] arr3 = {players.get(2).get(0).count,players.get(2).get(1).count,
                players.get(2).get(2).count};
        swap(arr1);
        swap(arr2);
        swap(arr3);
        String[][] cur = {arr1,arr2,arr3};
        for (int i = 0; i < 3; i++) {
            if (cur[i][0].equals(cur[i][1]) && cur[i][0].equals(cur[i][2])) {
                player[i] = 5000.0f;
                player[i] += compaire(cur[i]);
            } else if (cur[i][0].compareTo(cur[i][1]) == 1 && cur[i][1].compareTo(cur[i][2]) == 1) {
                player[i] = 4000.0f;
                player[i] += compaire(cur[i]);
            } else if (players.get(i).get(0).suit.equals(players.get(i).get(1).suit)
                    && players.get(i).get(0).suit.equals(players.get(i).get(2).suit)) {
                player[i] = 3000.0f;
                player[i] += compaire(cur[i]);
            } else if (cur[i][0].equals(cur[i][1]) || cur[i][0].equals(cur[i][2]) || cur[i][1].equals(cur[i][2])) {
                player[i] = 2000.0f;
                player[i] += compaire(cur[i]);
            } else if (cur[i][0].compareTo(cur[i][1]) != 0 && cur[i][0].compareTo(cur[i][2]) != 0
                    && cur[i][1].compareTo(cur[i][2]) != 0 ) {
                player[i] = 1000.0f;
                player[i] += compaire(cur[i]);
            }
        }
        float max = -1;
        int flag = -1;
        int flag2 = -1;
        int flag3 = -1;
        for (int i = 0; i < 3; i++) {
            if (player[0] == player[1] && player[0] == player[2]) {
                flag3 = 0;
            }
            if (player[i] > max) {
                max = player[i];
                flag = i + 1;
            } else if (player[i] == max) {
                flag2 = i + 1;
            }
        }
        if (flag2 != -1 && flag3 == -1) {
            System.out.println("玩家" + flag + "和" + flag2 + "的牌一样大");
        } else if (flag3 != -1) {
            System.out.println("三个玩家的牌一样大");
        }
        System.out.println("玩家" + flag + "的牌最大");
    }
    private static void swap(String[] arr) {
        String max1 = "";
        String max2 = "";
        String max3 = "";
        for (int i = 0; i < 3; i++) {
            if (arr[i].equals("10")) {
                arr[i] = ":";
            }
            if (arr[i].equals("J")) {
                arr[i] = ";";
            }
            if (arr[i].equals("Q")) {
                arr[i] = "<";
            }
            if (arr[i].equals("K")) {
                arr[i] = "=";
            }
            if (arr[i].equals("A")) {
                arr[i] = ">";
            }
        }
        if (arr[0].compareTo(arr[1]) > 0) {
            max2 = arr[0];
            max3 = arr[1];
            if (arr[2].compareTo(max2) > 0) {
                max1 = arr[2];
            } else if (arr[2].compareTo(max2) < 0){
                max1 = max2;
                if (arr[2].compareTo(max3) > 0) {
                    max2 = arr[2];
                } else {
                    max2 = max3;
                    max3 = arr[2];
                }
            } else {
                max1 = arr[2];
            }
        } else if(arr[0].compareTo(arr[1]) < 0){
            max2 = arr[1];
            max3 = arr[0];
            if (arr[2].compareTo(max2) > 0) {
                max1 = arr[2];
            } else if (arr[2].compareTo(max2) < 0) {
                max1 = max2;
                if (arr[2].compareTo(max3) > 0) {
                    max2 = arr[2];
                } else {
                    max2 = max3;
                    max3 = arr[2];
                }
            } else {
                max1 = arr[2];
            }
        } else if (arr[0].compareTo(arr[1]) == 0) {
            if (arr[2].compareTo(arr[1]) == 0) {
                max1 = arr[0];
                max2 = arr[0];
                max3 = arr[0];
            } else if (arr[2].compareTo(arr[1]) > 0) {
                max1 = arr[2];
                max2 = arr[1];
                max3 = arr[0];
            } else {
                max3 = arr[2];
                max2 = arr[0];
                max1 = arr[1];
            }
            arr[0] = max1;
            arr[1] = max2;
            arr[2] = max3;
            return;
        }
        arr[0] = max1;
        arr[1] = max2;
        arr[2] = max3;
        return;
    }
    private static float compaire(String[] arr) {
        float[] ret = new float[3];
       for (int i = 0; i < 3; i++) {
           if (arr[i] == ">") {
               ret[i] = 0.13f;
           } else if (arr[i] == "=") {
               ret[i] = 0.12f;
           } else if (arr[i] == "<") {
               ret[i] = 0.11f;
           } else if (arr[i] == ";") {
               ret[i] = 0.10f;
           } else if (arr[i] == ":") {
               ret[i] = 0.09f;
           } else if (arr[i] == "9") {
               ret[i] = 0.08f;
           } else if (arr[i] == "8") {
               ret[i] = 0.07f;
           } else if (arr[i] == "7") {
               ret[i] = 0.06f;
           } else if (arr[i] == "6") {
               ret[i] = 0.05f;
           } else if (arr[i] == "5") {
               ret[i] = 0.04f;
           } else if (arr[i] == "4") {
               ret[i] = 0.03f;
           } else if (arr[i] == "3") {
               ret[i] = 0.02f;
           } else if (arr[i] == "2") {
               ret[i] = 0.01f;
           }
           if (i == 0) {
               ret[i] *= 1000;
           } else if (i == 1) {
               ret[i] *= 10;
           } else {
               ret[i] *= 1;
           }
       }
       return ret[0] + ret[1] + ret[2];
    }
}

效果展示：每次启动都会随机发牌。
在这里插入图片描述

项目源码：https://github.com/YTCfight/ZhaJinHua/blob/master/src/KaPai.java

&从小白到大白&
关注
  • 7
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
基于Java实现炸金花扑克游戏
m0_53572054的博客
05-17 3335
指的是三张牌，上面的点数是连续排列的，而且花色相同。最大的牌型是AKQ，最小的牌型是A23.指的是三张牌中有两张牌是一对，也就是点数相同。盘面最大的是AAK，最小的是223。指的是三张牌牌面上的点数是连续的，但是花色不同。其中AKQ最大，A23最小。指的是三张牌，花色完全相同。其中牌型最大的是AKQ，最小的是352。也就是三张完全一样的牌，其中三个A是最大的，三个2是最小的。出现单张牌的情况下，最大的牌是AKJ，最小的是352。
使用Java炸金花
xy164914506的博客
09-16 299
的创建、洗牌、发牌、大小对比，输出赢家牌；
用Java语言简单实现：炸金花，不知道你有没有兴趣跟着笔者来研究一下呀
weixin_64308540的博客
12-15 1690
用Java语言简单实现：炸金花，不知道你有没有兴趣跟着笔者来研究一下呀？？？
java作业炸金花
2302_76549273的博客
09-16 71
List集合与List集合之间是可以嵌套的，使用List作为该方法的返回值，外层的List集合中代码每一个玩家，内层的List中代表玩家的扑克牌数。// 存储牌面值的大小规则。// 将当前玩家添加到玩家列表中。System.out.print("最大的手牌是玩家"+(maxIndex+1)+"：");存储牌盒中的key键值，与牌盒中的牌一一对应，用于取出牌盒中的牌，对牌号的操作等同于对牌盒操作。存储牌盒中的key键值，与牌盒中的牌一一对应，用于取出牌盒中的牌，对牌号的操作等同于对牌盒操作。
JavaScript实现炸金花
iamdavis的博客
08-31 6162
下面的代码是用Java Script实现炸金花的功能，目前基本所有牌大小的比较都已经实现了，目前没有花色比较的功能 9♠|8♠|3♠ 9♣|8♣|3♣ 这个我就会默认取前面是最大的，除此之外其他的比较应该都已经实现了（我不确定有没有考虑到所有的情况，有发现问题欢迎指出）。 代码运行出来的结果如下： 根据老师提供的思路做了对应的修改，具体的代码如下，代码里面也做了比较详细备注，仅供参考，...
专题之java炸金花代码.pdf
10-04
专题之java炸金花代码.pdf
扑克牌小游戏（Java）
05-17
一个扑克牌的小游戏
抓金花游戏(java版）
10-05
【抓金花游戏（Java版）】是一款使用Java编程语言实现的桌面娱乐游戏，它基于中国流行的扑克牌玩法“三公”（也称“金花”）。在这个游戏中，玩家通过比较手中的三张牌来决定胜负，牌型的大小决定了游戏的结果。本...
java扎金花程序java
05-02
javaSE写的一个扎金花作业。该程序实现了扎金花游戏的所有功能。适合新学java的学者学习下。当然由于个人单独写的，时间也比较紧所有可能存在些小问题或者哪里实现方式不好。还望读者能够批评指出。
微信小程序代码-小程序完整demo：飞翔的小鸟：canvas实现，java后端(适用1221).zip
04-22
该压缩包文件包含了一个微信小程序的完整示例项目，名为"飞翔的小鸟"，它主要展示了如何使用canvas技术和Java后端来开发一个互动游戏。在这个项目中，开发者可以学习到以下关键知识点： 1. **微信小程序开发基础**...
java版金花3人游戏逻辑代码
11-22
三人一起玩的zha金花游戏，代码实现随机9张牌，每人三张牌，判断牌面大小
JAVA学习练习（扎金花与21点）
Heavy_ANT的博客
04-27 2966
目前转行学习JAVA。记得N年学过C++，接触JAVA后感觉上手比较容易。学习半月熟练使用循环、判断，自行看书了解JAVA类的使用，并尝试用类完成编程。大概完成了老师题目，纯新一个，类和方法用得很混乱，但是总归做出来了！ 设计思路： 一、扑克牌类的建立 最初想法：将牌组建立为 int pkp[][]=new pkp[4][13]； 直接赋值2—14（目的可以很直接得到花色和大小）。通
炸金花大小比较算法(Java版)
热门推荐
编码之旅
06-17 2万+
炸金花大小比较算法，实现算法特点： 1）采用面向对象方式实现，分别构造牌面值的对象(枚举)、牌的花色对象(枚举)、玩家三张牌的类型(枚举，如豹子、同花顺等)、一张扑克牌对应的对象(一张牌有一个牌面值属性、一个花色属性)、玩家对象(玩家有3张扑克牌，牌的类型属性)； 2）主要是通过Java Comparable 接口的compareTo实现比较功能，很方便对玩家手中的牌进行排序(调用Collections.sort方法实现)，同事避免了很多if else 比较；
java炸金花
最新发布
2302_76552038的博客
09-25 106
/ 花色 (如：红心、梅花、方块、黑桃)// 重写 toString 方法以显示扑克牌的格式为 "{花色 数字}"private int rank;// 数字 (1-13)// 方法用于将牌分发给玩家（3个玩家，每人5张牌）// 方法用于创建一副扑克牌（52张牌）// 构造函数初始化花色和数字。// 辅助方法，用于交换牌堆中的两张牌。// 获取花色和数字的方法。// 方法用于利用随机数生成器洗牌。// 字符串数组，表示不同的花色。// 内部类表示一张扑克牌。
Java模拟炸金花
JHsjdh的博客
09-16 140
要实现模拟炸金花，需要满足以下几个条件：实现扑克牌的创建洗牌发牌大小对比输出赢家牌架构思想：首先需要创建三个集合，用于存储牌面值、牌号与比较规则，再创建一个类作为牌。其次还需要了解到一个工具类，就是Collections类，该类的所有方法都是由 static 静态关键字修饰的，所以该类的所有方法都可直接使用 类名+. 的方式调用。Collections类是针对集合的一个工具类，里面的所有方法就是针对集合来写的。
炸金花绝对大小计算、比较及排序算法(Java)，包含花色参与和不参与大小比较
zyzhehe的专栏
12-24 1万+
昨日忽生兴趣，想起同事正在玩的一个炸金花游戏，见他们讨论略有激烈，想来蛮有趣，于是自己也写来玩玩。 因有要一次产生很多副牌的需求（可能上1000），要对所有的玩家进行一个排序，因此考虑一个能得到每幅牌的绝对大小的统一算法。牌大小计算算法花色不参与大小比较: 首先对到手的牌按照牌数字按照由大到小排序 牌大小按照牌型分级 对于普通牌型，每张牌视为16进制的一个数，A对应14，2对应2，以此类推。牌值即
Java炸金花
2301_76534562的博客
09-15 53
/调用时，产生随机的花色和数字。i++) { //外循环为4种花色。System.out.println("第 "+(i+1)+"个人的牌："+hand.get(i));System.out.println("剩下的牌");System.out.println("洗牌：");System.out.println("揭牌：");
用Java实现扑克牌游戏——简易炸金花
zuozuo6868的博客
09-15 181
首先新建洗牌后的牌库集合对象与揭牌人的集合对象，然后通过add()方法将揭牌得到的扑克牌添加到对应的揭牌人集合对象中。最后返回改变后的牌库集合对象。首先新建对象，并进行买牌操作，输出所有的52张扑克牌，再进行洗牌并输出结果，然后进行揭牌操作，最后通过for循环输出揭牌的结果，并输出除揭牌已获取的扑克牌外剩余的扑克牌。首先给予扑克牌4种不同的花色，再为所有扑克牌创建新的扑克牌集合对象，通过两次for循环获取除大小王外的其他52张牌，并将其添加到该集合中，最后返回所有52张扑克牌。二.代码（注释）呈现。
用python写一段纸牌游戏
03-31
3. 炸金花：玩家手中有三张牌，可以选择跟注、加注或弃牌。最后留下的玩家揭示牌面，谁的牌面最大谁就获胜。 4. 斗地主：三个玩家轮流出牌，先出完所有牌的玩家获胜，牌型大小规则为单张、对子、三带一、炸弹等。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值