Java扑克游戏（多人多牌数比较游戏）的实现

最新推荐文章于 2023-02-13 21:15:17 发布
最新推荐文章于 2023-02-13 21:15:17 发布
阅读量3.8k 收藏 9
点赞数

具体实现步骤如下：

  1. 实现扑克Card类，用于储存扑克牌，1-13代表点数，4-1代表花色（黑桃，红桃，梅花，分块）
  2. 实现扑克列表CardList类，用于实现生成一副牌，洗牌，发牌的功能
  3. 实现玩家Player类，用于储存玩家信息
  4. 实现玩家列表PlayerList类，用于储存所有玩家信息，并且实现玩家洗牌、发牌、比较牌大小的方法
  5. 主方法Index05类，用于启动扑克游戏

Card.java

/**
 * 
 */
package dk.card;

/**
 * @author Administrator
 * 扑克类
 */
public class Card implements Comparable<Card>{
    private int number;//牌的点数--1到13
    private int type;//牌的花色--4种花色：♠(黑桃):4  ♥(红桃):3 ♣(梅花):2  方块:1

    public Card() {
        super();
    }
    public Card(int number, int type){
        if(number==1)
            number=14;
        this.number = number;
        this.type = type;
    }
    public int getNumber() {
        return number;
    }
    public void setNumber(int number) {
        this.number = number;
    }
    public int getType() {
        return type;
    }
    public void setType(int type) {
        this.type = type;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + number;
        result = prime * result + type;
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Card other = (Card) obj;
        if (number != other.number)
            return false;
        if (type != other.type)
            return false;
        return true;
    }
    @Override
    public int compareTo(Card o) {
        if(this.number>o.number)
            return -1;
        else if(this.number<o.number)
            return 1;
        else
            if(this.type>o.type)
                return -1;
            else if(this.type<o.type)
                return 1;

        return 0;
    }

    public String toString(){
        String str ="";
        switch(this.type){
        case 1: str = "方块";break;
        case 2: str = "梅花";break;
        case 3: str = "红桃";break;
        case 4: str = "黑桃";break;
        }
        String n="";
        switch(this.number){
        case 14:n="A";break;
        case 11:n="J";break;
        case 12:n="Q";break;
        case 13:n="K";break;
        default:n=this.number+"";
        }
        return str+n;
    }

}

CardList.java

package dk.card;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * @author Administrator
 * 牌表操作类
 */
public class CardList {
    public static List<Card> cardlist = new ArrayList<Card>(52);//储存扑克牌
    public static List<ArrayList<Card>> poker;//储存发牌结果

    //生成一副牌
    public static void generateCard() {
        for(int i=1;i<=13;i++){
            for(int j=1;j<=4;j++){
                Card c = new Card(i,j);
                cardlist.add(c);
            }
        }

    }

    //打印一副牌
    public static void printCardList(){
        System.out.print("[");
        for(Card c:cardlist){
            System.out.print(c.toString()+"  ");
        }
        System.out.println("]");
    }

    //洗牌
    public static void shuffleCard(){
        List<Card> scard = new ArrayList<Card>(52);
        Card c;
        Random random = new Random();
        for(int i=1;i<=52;i++){

            do{
                 c = cardlist.get(random.nextInt(52));
            }while(scard.contains(c));
            scard.add(c);
        }
        cardlist.clear();
        cardlist = scard;
        printCardList();
    }

    /**
     * 发牌
     * @param i number of player
     * @param j number of card
     * @return
     */
    public static List<ArrayList<Card>> dealCard(int i,int j){ 
        try{
            if(i<=1){
                throw new Exception("发牌规则有误：玩家至少为2人，请重新定义规则！");
            }
            if(i*j>52){
                throw new Exception("发牌规则有误：牌数超出扑克张数，请重新定义规则！");
            }

            poker = new ArrayList<ArrayList<Card>>(i);//储存玩家发到的牌

            //生成玩家手中的牌列表
            for(int h=0;h<i;h++){
                ArrayList<Card> player_card_list = new ArrayList<Card>(j);
                poker.add(player_card_list);

            }
            //给每个玩家发牌
            for(int k=0;k<j;k++){
                for(int d=0;d<i;d++){
                    ArrayList<Card> player_card_list = poker.get(d);
                    Card card = getCard();                  
                    player_card_list.add(card);
                }
            }

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

    //抓取一张牌
    public static Card getCard(){
        return cardlist.remove(0);
    }

    //获取一位玩家的牌
    public static ArrayList<Card> getPoker(){
        return poker.remove(0);
    }

    public static void clear(){
        cardlist.clear();
        poker.clear();
        printCardList();

    }

}

Player.java

/**
 * 
 */
package dk.card;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @author Administrator
 * 玩家类
 */
public class Player implements Comparable<Player>{
    private String id;//玩家id
    private String name;//玩家姓名
    private List<Card> poker;//玩家手牌
    private Card max;//玩家最大的牌
    public Player(String id ,String name){
        this.id = id;
        this.name = name;
        this.setPoker(new ArrayList<Card>());
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public List<Card> getPoker() {
        return poker;
    }

    public Card getMax() {
        return max;
    }
    public void setMax(Card max) {
        this.max = max;
    }
    public void setPoker(List<Card> poker) {
        this.poker = poker;
        Collections.sort(this.poker);
        for(Card c :this.poker){
            this.setMax(c);
            break;
        }
    }
    public String toString(){
        return "玩家Id："+this.id+"\t玩家姓名："+this.name;
    }

    //玩家摊牌
    public String showCard(){
        String msg="";
        for(Card c:this.poker){
            msg+=c.toString()+" ";
        }
        return this.toString()+"\t\n"+"玩家牌信息：\t\n"+msg;
    }
    @Override
    public int compareTo(Player o) {
        return this.max.compareTo(o.getMax());
    }

}

PlayerList.java

package dk.card;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @author Administrator
 * 储存玩家列表
 */
public class PlayerList {

    public static List<Player> playerlist = new ArrayList<Player>();//储存扑玩家列表
    public static int sum;
    public static List<String> rules = new ArrayList<String>();
    public PlayerList(){

    }

    public static void setRule(String rule){
        rules.add(rule);
    }

    public static String getRules(){
        String str="";
        for(String s:rules){
            str+=s+"\t\n";
        }
        return str;
    }

    public static void printRules(){
        show(getRules());
    }

    //添加玩家
    public static boolean addplayer(Player player){
        show("添加玩家："+player.toString());
        show("----------------------------------------");
        sum++;
        return playerlist.add(player);
    }

    //给所有玩家发牌
    public static void shuffleCardToPlayer(){
            for(Player player:playerlist){
                player.setPoker(CardList.getPoker());
            }
    }   

    //显示发牌结果
    public static void showCard(){
        for(Player player:playerlist){
            show(player.showCard());
            show("----------------------------------------");
        }
    }

    //比较牌点大小并且显示赢家信息
    public static void showWinner(){
        Collections.sort(playerlist);
        Player p = playerlist.get(0);
        show(p.showCard());
        show("本局赢家是："+p.getName());
    }

    //玩家人数
    public static int size(){
        return sum;
    }

    public static void show(Object obj){
        System.out.println(obj.toString());
    }

    public static void clear(){
        playerlist.clear();
        sum = 0 ;
    }

}

Index05.java

/**
 * 
 */
package dk.main;

import java.util.Scanner;

import dk.card.CardList;
import dk.card.Player;
import dk.card.PlayerList;

/**
 * @author Administrator
 *
 */
public class Index05 extends Show {

    public static Scanner scanner = new Scanner(System.in);

    /**
     * 调用的主方法
     * @param args
     */
    public static void main(String[] args) {
        show("是否开始游戏?0/1");
        int isStart = scanner.nextInt();
        if(isStart==1){
            startGame();
        }   
        else{
            show("退出游戏！");
        }

    }

    //启动扑克游戏
    public static void startGame(){
        show("游戏规则如下:");
        PlayerList.setRule("1.至少需要两名玩家");
        PlayerList.setRule("2.所有玩家的牌数加起来不超过52张牌");
        PlayerList.setRule("3.比较所有玩家手中最大的牌点，最大的牌点数的玩家获胜");
        PlayerList.setRule("4.总的牌数只有52张，没有大小王");
        PlayerList.setRule("5.黑桃牌A最大，方块3最小，点数相同时，比较花色，黑桃较大。");
        PlayerList.printRules();
        show("请输入玩家人数：");
        int players = 2;//默认玩家数目
        int cardofplay = 2;//默认每个玩家的手牌数目
        try {
             players = scanner.nextInt();
                while(players<2){
                    show("玩家人数至少是两人");
                    show("请重新输入人数：");
                    players = scanner.nextInt();
                }

                show("请输入每个玩家持有的牌数：");  
                cardofplay = scanner.nextInt();
                while(cardofplay*players>52){
                    show("玩家*牌数超出范围！请重新输入牌数");
                    cardofplay = scanner.nextInt();
                }

                show("开始输入玩家信息:");
                for(int i=0;i<players;i++){
                    show("请输入第"+(i+1)+"个玩家姓名:");
                    String name = scanner.next();
                    Player p =new Player("00"+i,name);
                    PlayerList.addplayer(p);
                }
                show("一副没有洗的牌：");
                CardList.generateCard();//生成一副扑克
                CardList.printCardList();//打印扑克
                show("========================================");
                show("开始洗牌：");
                CardList.shuffleCard();//洗牌
                show("========================================");
                show("开始发牌：........发牌中......");
                CardList.dealCard(players,cardofplay);//发牌
                PlayerList.shuffleCardToPlayer();//给玩家发牌
                show("发牌结果：");
                PlayerList.showCard();//显示所有玩家牌信息
                show("========================================");
                show("比较结果：比较牌点大小并且显示赢家信息");
                PlayerList.showWinner();//显示本轮赢家
                show("========================================");
        } catch (Exception e) {

            e.printStackTrace();
        }
    }

    //清空游戏
    public static void clearGame(){
            CardList.clear();
            PlayerList.clear();
    }

    //测试扑克游戏
    public static void testGame(){
        try {
            show("一副没有洗的牌：");
            CardList.generateCard();
            CardList.printCardList();
            show("========================================");
            show("开始添加玩家：");
            Player p =new Player("001","DekingChen");
            Player p1 =new Player("002","chenzhenquan");
            Player p2 =new Player("003","czq");
            PlayerList.addplayer(p);
            PlayerList.addplayer(p1);
            PlayerList.addplayer(p2);
            show("开始洗牌：");
            CardList.shuffleCard();
            show("========================================");
            show("开始发牌：........发牌中......");
            int players =  PlayerList.size();//玩家数目
            int cardofsum = 3;//每个玩家的手牌数目
            CardList.dealCard(players,cardofsum);
            PlayerList.shuffleCardToPlayer();
            show("发牌结果：");
            PlayerList.showCard();
            show("========================================");
            show("比较结果：比较牌点大小并且显示赢家信息");
            PlayerList.showWinner();
            show("========================================");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

Show.java(辅助显示类)

package dk.main;

public abstract class Show {

    public static void show(Object obj){
        System.out.println(obj.toString());
    }
}

实验结果：

是否开始游戏?0/1
1
游戏规则如下:
1.至少需要两名玩家  
2.所有玩家的牌数加起来不超过52张牌 
3.比较所有玩家手中最大的牌点，最大的牌点数的玩家获胜 
4.总的牌数只有52张，没有大小王   
5.黑桃牌A最大，方块3最小，点数相同时，比较花色，黑桃较大。 

请输入玩家人数：
5
请输入每个玩家持有的牌数：
5（<a href="http://www.dztcsd.com/">资质代办</a>）
开始输入玩家信息:
请输入第1个玩家姓名:
DekingChen
添加玩家：玩家Id：000   玩家姓名：DekingChen
----------------------------------------
请输入第2个玩家姓名:
czq
添加玩家：玩家Id：001   玩家姓名：czq
----------------------------------------
请输入第3个玩家姓名:
chenzhenquan
添加玩家：玩家Id：002   玩家姓名：chenzhenquan
----------------------------------------
请输入第4个玩家姓名:

作者： DekingChen 
来源：慕课网
本文原创发布于慕课网 ，转载请注明出处，谢谢合作！
大志天成119
关注
Java扑克牌小游戏
Timothy
04-14 1037
一、游戏规则如下： 1.创建一副扑克牌，包括2-10，J,Q,K,A.四种花色黑红梅方。无大小王  2.创建两名玩家，有ID，姓名，手牌等属性，手牌为扑克牌的集合 3.洗牌。将之前创建的扑克牌打乱顺序 4.发牌。洗牌之后的扑克牌集合，从第一张开始，发给两名玩家，按照一人一张的方式，每人两张 5.游戏，比较两名玩家手中的扑克牌，规则为：取两人各自手中点数最大的牌进行比较，点数大的赢；
用Java编写简单的扑克牌游戏
l9528的博客
08-01 4535
昨天我帮助一位朋友解决了这个问题，今天我即兴想写一篇详细的关于用Java编写扑克牌游戏的文章。 当然我这里只是实现一些简单的功能。 关于扑克牌游戏的特征，想必大家都有所接触过，有扑克牌，玩扑克牌游戏的玩家还有玩法。 扑克牌的特点是它有点数和花色，当然大小王除外，大小王没有花色。 玩扑克牌游戏的玩家的特点是他们都有一个游戏名称，还有就是在玩扑克牌游戏时，他们还有一个特点就是游戏中的身份，是地主还是农民，除此之外，他们手中还有扑克牌。 至于玩法就是首先得有3个人，然后就开始洗牌，发牌，抢地主...
Java扑克牌游戏
02-27
一个完全由Java编写的扑克小游戏，完全是自己独立编写的，图形界面尚未完善，之后会持续更新，程序支持发牌看牌，出牌，系统随机发牌。
扑克牌游戏（Java实现）
m0_58086930的博客
09-07 2343
思路： i:创建牌 一张纸牌包含花色和字符 一副扑克牌：4种花色：黑桃、红桃、梅花、方块 17种字符：2~10 J~A 大、小王 ii:洗牌 通过随机数获取原数组下标，但是所参产生的随机数会重复，所以用个标识数组 iii:发牌 玩家1的牌的数组下标是0，3，6，9... 玩家2的牌的数组下标是1，4，7，10... 玩家1的牌的数组下标是2，5，8，11... ...
JAVA简易扑克牌游戏
安迪名爵的专栏
11-24 1635
一直是C#的忠实粉丝，近来想和JAVA来个亲密接触，随即跟着慕课网  一步一步学起了JAVA。 Java入门第一季、第二季、第三季课程还是值得初学者仔细品读，认真完成每一个小练习。 最后，讲师留了一个JAVA简易扑克牌游戏的题目，代码如下，供需要者参考： Poker.java /**  *  */ package andy_poker; import jav
java实现多人多牌数比较游戏
08-26
本文将详细介绍如何使用Java实现多人多牌数比较游戏，主要包括了扑克类、扑克列表类、玩家类、玩家列表类和主方法索引类的实现。 1. 扑克类（Card.java） 扑克类是游戏的基础，用于储存扑克牌的信息。该类实现了...
Java扑克牌游戏网络对战版
03-16
在本项目中，"Java扑克牌游戏网络对战版"是一个基于Java开发的多人在线扑克牌游戏。这个项目的核心特点是支持玩家之间的实时网络对战，让玩家能够跨越地理限制，享受与朋友或陌生人竞技的乐趣。下面我们将深入探讨该...
PokerGame_Java.rar_PokerGame_java 三公_java牌多线程_扑克 gui java
09-24
《Java实现扑克游戏“三公”：GUI设计与多线程技术详解》 在计算机科学领域，游戏开发是一项集趣味性、技术性和创新性于一体的挑战。本项目名为"PokerGame_Java"，是一款基于Java语言设计的多媒体扑克游戏，遵循...
小程序 源码带服务端多人在线扑克（源码+截图）.rar
最新发布
03-19
免责声明：资料部分来源于合法的互联网渠道收集和整理，部分自己学习积累成果，供大家学习参考与交流。收取的费用仅用于收集和整理资料耗费时间的酬劳。 本人尊重原创作者或出版方，资料版权归原作者或出版方所有，...
用java开发的扑克牌游戏程序源代码
11-25
在本项目中，"用Java开发的扑克牌游戏程序源代码"是一个基于Java...以上就是这个Java扑克牌游戏项目可能涉及的关键技术点。通过学习和分析这个源代码，开发者不仅可以提升Java编程技能，还能了解到游戏开发的实战经验。
扑克牌游戏完整Java代码.rar
07-10
Java写的扑克牌游戏完整代码， @author 叶少伟。编译时要用到swing组件，请确保你的JDK环境有此组件。
Java实现的联机多人对战五子棋游戏，带聊天功能
09-06
Java实现的联机多人对战五子棋游戏，带聊天功能，可开多队同时对战
100行搞定java简单扑克牌游戏
07-20
100行代码实现简单扑克牌游戏，能够生成扑克牌，洗牌，创建玩家（玩家姓名输入限定为中文）两名，玩家分别取两张牌，然后谁的手牌大输出谁获胜。
JAVA程序设计_具有发牌洗牌功能的纸牌游戏
10-10
每张牌都有花色和数字两个属性。纸牌游戏有2副牌参与（没有Joker,共104张）， 应有洗牌（将所有牌打乱）、发5张牌、判断游戏胜利、判断游戏失败的功能。 每次发牌后程序自动为5张牌排序、游戏胜利条件为5张牌中至少有2张是完全相同的，或者5张同花色，或者5张为顺子（如数字为34567）； 如果不满足游戏结束条件则继续在从剩下的牌中发5张；直到最后不足5张，游戏失败。
JAVA小游戏——扑克牌游戏
CallMeSa1tyFish的博客
08-21 1454
游戏简介 一共两位玩家，发两轮牌，最后比较每个人手中最大的牌，较大的玩家获胜。 同花色中2最小，A最大。不同花色的排序为：方片&lt;梅花&lt;红桃&lt;黑桃 （游戏无图形页面） 游戏源码 主类：Game类 import java.util.HashMap; import java.util.Map; import java.util.Scanner; public clas...
JAVA入门之简易扑克牌游戏
long_lo的博客
07-30 635
游戏规则：2名玩家，每人随机拿2张牌，取各自大的那张，进行比较，得出获胜者。 共52张牌，没有大小王。先比较点数，若点数相同则比较花色。 从大到小为：A,K,Q,J,10，9，8，7，6，5，4，3，2 从大到小为：”黑桃”,”红桃”,”梅花”,”方块“” Cardspackage com.imooc;import java.util.ArrayList; import java.util.
java实现简易扑克牌游戏
lc1978037519的博客
03-29 1221
简易扑克牌游戏：功能： 创建一副扑克牌，花色为：黑桃，红桃，梅花，方片，且依次变小， 数字为：”2”,”3”,”4”,”5”,”6”,”7”,”8”,”9”,”10”, “J”,”Q”,”K”,”A”，且依次增大； 洗牌，即对扑克牌随机排序； 创建2名玩家，每名玩家手中两张牌，比较输出赢家。 以下为java代码： 扑克牌类:Poker**/** * 扑克牌类 * @auth
Java实现扑克牌游戏（简易炸金花）
xyk：的博客
02-13 3820
在游戏开始之前要创建扑克牌，其中扑克牌要具有花色和数字，而且要记住除了大小王以外，扑克牌工有四种花色，52张牌。要重写toString方法！在玩之前，要将买来的牌用Random函数进行重新打乱，以便于每个人手中的牌大小不一样。要先将52张扑克牌创建出来，并添加到集合中，以便于后续操作。每个人要进行抓牌，设置每个人手中抓五张牌，三个人进行游戏。
Java实现多人扑克牌比较游戏
在Java编程中，设计这样一个多人多牌数比较游戏，我们需要以下几个关键类： 1. **Card类**： - `Card` 类用来表示扑克牌，它包含两个属性：`number` 和 `type`。 - `number` 用于存储牌的点数，1-13 代表点数，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值