控制台实现斗地主

已于 2022-11-05 17:44:01 修改
阅读量750 收藏 3
点赞数 1
分类专栏： java 文章标签： java 开发语言
于 2022-11-05 17:42:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57816620/article/details/127701582
版权

最近给大家分享一个在学习过程中比较有意义的面向对象的思想的控制台实现斗地主

要求大概就是有一个地主、两个农民，一副牌，谁先出完牌谁就获胜，简单的思路。

遇到这种面向对象的题目时首先需要分析一下，理清一下思路。

1、分析

首先我们需要一个人物类，人物类有一个集合装每个人的牌（农民17张，地主20张），有姓名（地主，或者农民），还有一个判断是否是地主的属性，人物还有出牌的方法

还要有一个游戏类，有一个集合装54张牌，有花色和大小两个属性，有发牌，洗牌，判断地主等方法

初步分析就大概这些东西，编写过程中遇到问题再慢慢修复

首先，写一个游戏类里面有花色和牌的大小

 private static final String[] pokecard = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2", "小王", "大王"};  //牌的值
    private static final String[] pokecolor = {"♠", "♥", "♣", "♦"};   //牌的花色

然后，构造一个54张牌的容器用来装牌

  //生成一副牌的方法
    public  static ArrayList makePoke(){
        //将牌装入集合中
        ArrayList poke = new ArrayList<>();
        for(int i=0;i<pokecard.length-2;i++){
            for(int j=0;j<pokecolor.length;j++){
                String s = pokecolor[j] + pokecard[i];
                poke.add(s);
            }
        }
        //大小王没有花色，单独装进集合中
        poke.add(pokecard[pokecard.length-2]);
        poke.add(pokecard[pokecard.length-1]);
        return poke;
    }

然后也要洗牌，用集合的shuffle方法打乱牌的顺序即可

private   ArrayList xipai(ArrayList list){
        Collections.shuffle(list);
        return list;
    }

写的详尽一点的话，可以写一个选地主的一个方法，随机挑选地主，如下：

   public void xuandizhu(Person p1,Person p2, Person p3){
        Random random = new Random();
        int n=random.nextInt(3)+1;
        if(n==1){
            System.out.println(p1.getName()+"当选地主");
            p1.setDiZhu(true);
        }else if(n==2){
            System.out.println(p2.getName()+"当选地主");
            p2.setDiZhu(true);
        }else if(n==3){
            System.out.println(p3.getName()+"当选地主");
            p3.setDiZhu(true);
        }
    }

然后进行发牌，写一个发牌的方法，里面传入三个人物，用每个集合单独装，地主的话最后三张牌给它即可

  public void fapai(ArrayList list,Person p1,Person p2,Person p3){
        ArrayList list1 = xipai(list);
        xuandizhu(p1,p2,p3);
       for(int i=0;i<list.size()-3;i+=3){
               p1.getPoke().add(list1.get(i));
               p2.getPoke().add(list1.get(i+1));
               p3.getPoke().add(list1.get(i+2));
       }
       if(p1.isDiZhu()){
           p1.getPoke().add(list1.get(list1.size()-3));
           p1.getPoke().add(list1.get(list1.size()-2));
           p1.getPoke().add(list1.get(list1.size()-1));
       }
       else if(p2.isDiZhu()){
           p2.getPoke().add(list1.get(list1.size()-3));
           p2.getPoke().add(list1.get(list1.size()-2));
           p2.getPoke().add(list1.get(list1.size()-1));
       }
       else if(p3.isDiZhu()){
           p3.getPoke().add(list1.get(list1.size()-3));
           p3.getPoke().add(list1.get(list1.size()-2));
           p3.getPoke().add(list1.get(list1.size()-1));
       }

    }

那么有一个问题就是，打乱了牌的顺序，如何能够正确的在控制台上显示牌呢？所以需要用到排序，那么在斗地主中，JQKA2这些牌是没办法通过自然排序的，所以我们这里自定义一个比较器

如下，我想到的是用asii码来比较

 @Override
    public int compare(String o1, String o2) {
        char m = 0 ,n = 0;
        if(o1.charAt(1) == '2'){
            m = 'M';
        }
        else if(o1.charAt(1) == '1'){
            m = ':';
        }
        else if(o1.charAt(1) == 'J'){
            m = 'I';
        }
        else if(o1.charAt(1) == 'Q'){
            m = 'J';
        }
        else  if(o1.charAt(1) == 'A'){
            m = 'L';
        }
        else if(o1.charAt(0) == '大'){
            m = 'O';
        }
        else if(o1.charAt(0) == '小'){
            m = 'N';
        }
        else{
            m = o1.charAt(1);
        }
        if(o2.charAt(1) == '2'){
            n = 'M';
        }
        else if(o2.charAt(1) == '1'){
            n = ':';
        }
        else if(o2.charAt(1) == 'J'){
            n = 'I';
        }
        else if(o2.charAt(1) == 'Q'){
            n = 'J';
        }
        else if(o2.charAt(1) == 'A'){
            n = 'L';
        }
        else if(o2.charAt(0) == '大'){
            n = 'O';
        }
        else if(o2.charAt(0) == '小'){
            n = 'N';
        }
        else{
            n = o2.charAt(1);
        }
        return m - n;
    }

那么游戏类就大致写好了，再来看看人物类

private  String name;
    private ArrayList poke=new ArrayList();
    private boolean isDiZhu;

    static Scanner sc=new Scanner(System.in);
    public Person(String name, ArrayList poke) {
        this.name = name;
        this.poke = poke;
        this.isDiZhu=false;
    }

    public Person() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public ArrayList getPoke() {
        return poke;
    }

    public void setPoke(ArrayList poke) {
        this.poke = poke;
    }

    public boolean isDiZhu() {
        return isDiZhu;
    }

    public void setDiZhu(boolean diZhu) {
        isDiZhu = diZhu;
    }

这是基本的属性的封装和构造方法

还有一个理牌的功能实现，即调用上面写好的比较器即可

public void lipai(ArrayList list){
        Collections.sort(list,new Game());
    }

那么进行到了关键性的一步，也是最难的地方，就是出牌的方法，我们出牌的时候首先要判断手里有没有这些牌，出完牌后还要从集合中移除这些牌，所以可以用一个临时集合来存储，如果删除牌张的数量和出牌的数量相等，那么就出牌成功，反之则失败。如果失败就返回之前的不变的集合，如果成功就返回临时的集合来改变原有的集合，大概就是这样的思路。

 /**
     * 出牌的方法
     */
    public ArrayList sendPoke(ArrayList list){
        System.out.println(this.getPoke());
        ArrayList listTemp = new ArrayList<>();
        for(int i=0;i<list.size();i++){
            listTemp.add(list.get(i));
        }
        String str=sc.next();
        String[] split = str.split("");

        int i=0,n=0;
        Iterator iterator = listTemp.iterator();
        while(i<split.length){  //34567  3334
            while (iterator.hasNext()){
                String num = (String) iterator.next();
                if(num.contains(split[i])){
                    iterator.remove();
                    n++;
                    break;
                }
            }
            i++;
        }
        if(n==split.length){
            this.setPoke(listTemp);
            System.out.println("出牌成功");
        }else {
            System.out.println("出牌失败，没有这些牌");
        }
        return  this.getPoke();


    }

那么此时我们的一些小方法就写完了，来写测试类。构建对象，调用方法等可以封装到一个开始的方法里，并且判定，如果谁的牌出完了，谁就赢了。

public static  void start(){
        ArrayList list = Game.makePoke();  //54张牌的牌集合
        ArrayList list1 = new ArrayList<>(); //p1集合
        ArrayList list2 = new ArrayList<>(); //p2集合
        ArrayList list3 = new ArrayList<>(); //p3集合
        Person p1=new Person("zs",list1);
        Person p2=new Person("ls",list2);
        Person p3=new Person("ww",list3);
        Game game=new Game();
        game.fapai(list,p1,p2,p3);
        p1.lipai(list1);
        p2.lipai(list2);
        p3.lipai(list3);
        if (p1.isDiZhu()){
            while (true){
                System.out.print("地主出牌:");
                p1.sendPoke(p1.getPoke());
                if(p1.getPoke().size() == 0 ){
                    System.out.println("地主胜利");
                    break;
                }
                System.out.print("农民一出牌:");
                p2.sendPoke(p2.getPoke());
                if (p2.getPoke().size() == 0|| p3.getPoke().size() == 0){
                    System.out.println("农民胜利");
                    break;
                }
                System.out.print("农民二出牌:");
                p3.sendPoke(p3.getPoke());

                if (p2.getPoke().size() == 0|| p3.getPoke().size() == 0){
                    System.out.println("农民胜利");
                    break;
                }
            }

        }
        if (p2.isDiZhu()){
            while (true){
                System.out.print("地主出牌:");
                p2.sendPoke(p2.getPoke());
                if(p2.getPoke().size() == 0 ){
                    System.out.println("地主胜利");
                    break;
                }
                System.out.print("农民一出牌:");
                p3.sendPoke(p3.getPoke());
                if (p1.getPoke().size() == 0|| p3.getPoke().size() == 0){
                    System.out.println("农民胜利");
                    break;
                }
                System.out.print("农民二出牌:");
                p1.sendPoke(p1.getPoke());
                if (p1.getPoke().size() == 0|| p3.getPoke().size() == 0){
                    System.out.println("农民胜利");
                    break;
                }
            }

        }
        if (p3.isDiZhu()){
            while (true){
                System.out.print("地主出牌:");
                p3.sendPoke(p3.getPoke());
                if(p3.getPoke().size() == 0 ){
                    System.out.println("地主胜利");
                    break;
                }
                System.out.print("农民一出牌:");
                p1.sendPoke(p1.getPoke());
                if (p2.getPoke().size() == 0|| p1.getPoke().size() == 0){
                    System.out.println("农民胜利");
                    break;
                }
                System.out.print("农民二出牌:");
                p2.sendPoke(p2.getPoke());

                if (p2.getPoke().size() == 0|| p1.getPoke().size() == 0){
                    System.out.println("农民胜利");
                    break;
                }
            }

        }
    }

我这里还要分别判断谁是地主，地主先出牌。那么基本的方法就写完了，在main方法里直接调用开始的方法即可完成控制台实现斗地主。

效果如下

 

写的不是很好，但是对面向对象的思维性有很大的帮助！

时间总是会不够的啊
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简单java控制台斗地主
liuw510的博客
11-12 468
用java做了个简单控制台斗地主小游戏 实现了洗牌发牌抢地主的过程，整理牌面顺序 import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Scanner; imp...
Java实现控制台版斗地主（可出牌）
m0_65370826的博客
01-10 732
控制台版斗地主
上班划水神器：一个可以在控制台玩斗地主的项目！
Java知音
06-23 285
作者：矢泽妮可juejin.im/post/5be955a6f265da6135721bcc精彩推荐一百期Java面试题汇总SpringBoot内容聚合IntelliJ IDEA内容聚...
C++控制台游戏之--斗地主
04-16
C++初学者，使用控制台 写的一个斗地主的游戏，斗地主的所有牌型都可以出，但是电脑出牌不是很智能，还有很多需要改进的地方。
java基础——轻轻松松控制台斗地主
weixin_45053664的博客
04-19 1915
实现在控制台斗地主 今天给大家一起分享一下，最近回头学习java基础实现的一个控制台版的斗地主。先给大家简单看一下要求： 有地主，有2个农民，地主有额外3张牌。 游戏开始时，显示地主的牌，并从控制台接收要出的牌，地主出牌后。 农民1显示牌，并从控制台接收要出的牌，以此类推。 如果地主赢了，提示地主胜利。如果有一个农民胜利了，就提示农民胜利。 1.先理清逻辑 在开始敲代码之前，我们第一步一定不是急着动手。而是需要分析一下，我们做的这个项目，它一步一步的应该怎么来操作和完成。理清思路之后，其实剩下的就都是水到渠
一个简单的控制台斗地主java程序
01-14
一个简单的控制台斗地主小程序，JAVA语言
基于C++实现斗地主小游戏
08-28
在本项目中，"基于C++实现斗地主小游戏"是一个用C++编程语言开发的简单人工智能单机斗地主游戏。斗地主是一种在中国非常流行的扑克牌游戏，通常需要三名玩家参与，但在这个单机版本中，游戏可能设计为用户与两个...
在IDEA里斗个地主不过分吧！
小毅博客
06-15 1342
如果说，在IDEA里下个棋很过分，那在IDEA里斗个地主，是不是就更过分了？通过 命令登入服务器通过 命令查看游戏列表通过 命令运行游戏启动斗地主游戏命令 支持人机和联机两种游戏方式，咱们先来看下人机模式，直接点击 “开始游戏” 按钮内置的机器人有点笨笨的哦，小心你的队友，嘿嘿！开始游戏之后，系统会随机指定一名玩家优先叫分，叫分区间为 分，叫分高者为地主，也可以选择不叫，如果都不叫，则系统重新发牌，进行新一轮叫分，直到有人成为地主为...
java控制台模拟斗地主洗牌发牌
学不会就砸电脑——的博客
07-17 259
一个小的控制台项目，用于模拟斗地主洗牌和发牌，运行效果如下图所示 上家的 ♠3 ♣3 ♥5 ♣5 ◇5 ♥6 ♠7 ◇8 ♠9 ◇9 ◇10 ♠J ◇J ♥Q ♠K ♥A ♣A 我的 ♠4 ♥4 ◇4 ♠5 ♠6 ◇7 ♥8 ♥9 ♣9 ♠10 ♥J ♠Q ♣K ♠A ♠2 ◇2 小王 下家的 ♥3 ◇3 ♣4 ♣6 ◇6 ...
C#单机版斗地主源码
11-15
C#单机版斗地主源码，亲测可以运行，可以参考参考，代码写的很好
斗地主程序（一个用c++实现的功能不错的斗地主程序）
07-06
收集的一个关于c++的斗地主的程序，有兴趣的朋友可以下载学习交流！！！
一个可以在控制台玩斗地主的项目
weixin_38754349的博客
09-10 167
code小生一个专注大前端领域的技术平台公众号回复Android加入安卓技术群作者：矢泽妮可juejin.im/post/5be955a6f265da6135721bcc精彩推荐一个...
java控制台小程序(斗地主发牌功能)
Tsir_6_6的博客
07-17 344
java控制台小程序(斗地主发牌功能) 近期时间较少不做详细介绍了,请直接观察注释! 效果: (代码简陋,不喜勿喷TVT) 代码: Card类: /** * 牌堆 * @author ASUS * */ public class Card { /**点数*/ private String count; /**大小*/ private int size; public Card() { // TODO Auto-generated constructor stub } pub
实现斗地主发牌功能
akiaug的日录
01-05 637
编程实现控制台版支持三人对战的斗地主游戏(暂时只能发牌)。 代码分段 定义一些等会要用到的变量 private String cardA; //用户A private String cardB; //用户B private String cardC; //用户C private List A = new ArrayList(); //用户A的手牌 private List B = new ArrayList(); //用户B的手牌 privat
Java 面向对象练习题之斗地主游戏
Hello_qjh的博客
03-30 3507
题目： 参考斗地主的游戏规则，完成一个发牌的功能(54张牌，考虑点数，花色；三名玩家，其中地主比其他玩家多3张牌) * （1） 牌类(花色，点数，序号) * （2） 玩家类(id，名字，是否地主，牌集合) package cn.java.work; import java.util.*; /** * 斗地主 */ public class Game { //需要有一个属性.或者说是一个变量来存储54张牌 private HashMap<Integer,Str.
java 控制台斗地主 demo代码
闲走天涯的博客
09-10 491
扑克牌实体类 /** * 描述: * 实体类 扑克牌 * @author 闲走天涯 * @create 2021/3/17 17:09 */ public class Pai implements Comparable<Pai>{ private String name ; private String num ; private int id ; public Pai(String name, String num, int id) {
斗地主Java课程设计_JAVA面向对象编程课程设计——web版斗地主
weixin_39630880的博客
02-13 1070
一、团队课程设计博客链接二、个人负责模块或任务说明实体类的设计斗地主规则的实现人机自动出牌的算法实现数据库的DAO模式三、自己的代码提交记录注：这里只有部分提交记录，详细的提交记录在团队课程设计博客里有四、自己负责模块或任务详细说明1、实体类的设计的代码分析游戏设计需要用到卡片类(Card)正反面，还有牌型(CardType)的设计，以及各种牌的组合，还要设计在游戏中的抢地主、出牌倒计时、出牌和不...
代码实现斗地主发牌
Fer12138的博客
08-08 864
区别: 上面是用一个字符串数组来存储所有牌的组合，并且也是对字符串数组进行洗牌操作，较为麻烦，而用哈希表之后，我们可以对每一张牌对应的索引进行洗牌操作。并且上面也要求了，对每一位玩家的牌进行排序，而上面我们并没有实现，因此下面我们使用Treeset来保存每一位玩家所拿到的牌，确保完成了排序功能。3.洗牌，也就是把牌打散，用Collections的shuffle()方法实现。1.创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现。5. 看牌，也就是三个玩家分别遍历自己的牌。...
Python实现斗地主
最新发布
09-16
### 回答1： 你好! 要实现斗地主，你需要了解游戏的规则和基本流程。然后，你可以使用 Python 的类来模拟游戏的各个部分，包括玩家、牌堆、牌组、游戏流程等。 下面是一个简单的示例，展示了如何使用 Python 类来模拟斗地主游戏: ``` # 定义一个 Card 类表示单张牌 class Card: def __init__(self, suit, value): self.suit = suit self.value = value # 定义一个 Deck 类表示一副牌 class Deck: def __init__(self): self.cards = [] self.build_deck() def build_deck(self): suits = ['Spades', 'Hearts', 'Clubs', 'Diamonds'] values = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'] for suit in suits: for value in values: self.cards.append(Card(suit, value)) def shuffle(self): random.shuffle(self.cards) def deal(self): return self.cards.pop() # 定义一个 Player 类表示玩家 class Player: def __init__(self, name): self.name = name self.hand = [] def draw(self, deck): self.hand.append(deck.deal()) return self def show_hand(self): for card in self.hand: print(card.suit, card.value) # 定义一个 Game 类表示游戏 class Game: def __init__(self): self.deck = Deck() self.players = [] def add_player(self, player): self.players.append(player) def start(self): self.deck.shuffle() for i in range(3): for player in self.players: player.draw(self.deck) # 创建游戏实例，添加玩家，并开始游戏 game = Game() game.add_player(Player('张三')) game.add_player(Player('李四')) game.add ### 回答2： Python实现斗地主是一个非常有趣和具有挑战性的项目。下面是一个简单的实现思路： 首先，我们需要创建一副扑克牌，包含52张不含大小王的牌，可以使用列表来表示，每张牌用一个整数来表示。例如，1代表红桃A，2代表红桃2，以此类推。 接下来，需要实现洗牌功能，可以使用random模块的shuffle函数来随机打乱扑克牌列表的顺序。 然后，我们需要编写发牌函数，将一副洗好的牌平分给三个玩家，并将剩余的三张底牌放置在桌面上。 接下来，进入游戏阶段。轮流出牌，每位玩家根据当前的牌面情况，决定出哪些牌。可以实现一个简单的AI算法，根据牌面大小和规则来决定出牌策略。 在每次出牌之后，需要判断当前出牌是否符合规则，比如是否是合法的单牌、对子、三张牌、炸弹等等。并且需要更新当前的牌面情况，记录当前出牌的玩家是谁，以及当前的牌型和大小。 游戏过程中，需要实现一个计分系统，记录每位玩家的得分情况。根据谁先出完牌、谁先出完全部手上的牌以及底牌，来决定得分的分配。 最后，根据玩家的得分情况，判断谁是最终的胜者。 以上是一个简单的斗地主实现思路，Python作为一种高级编程语言，提供了丰富的数据结构和库函数，非常适合用来实现这样的项目。通过编写斗地主这样的小程序，能够锻炼我们的编程能力和逻辑思维，并且提供了一个有趣的游戏来娱乐自己和他人。 ### 回答3： Python实现斗地主是一种通过编程语言Python来编写斗地主游戏的实现方式。斗地主是一种中国常见的扑克牌游戏，通过编写Python代码来模拟和实现这种游戏，可以让玩家在电脑上进行斗地主游戏。 在Python中实现斗地主，首先需要定义并创建一副扑克牌，通常使用52张牌，不包括大小王。然后需要创建玩家类，可以通过编写Python的类来实现。玩家类可以包含一些属性，如玩家的姓名、手牌等信息，并提供一些方法用于玩家出牌、抢地主等操作。 接下来，需要实现斗地主的游戏逻辑。这包括洗牌、发牌、叫地主、出牌、判断胜负等步骤。可以通过编写一些函数或者方法来实现这些逻辑，例如洗牌函数、发牌函数、判断出牌类型函数等。 在实现斗地主的过程中，还可以考虑添加一些可视化的功能，如使用Python的图形库显示玩家的手牌、出牌等，在控制台或者图形界面中显示游戏进程和结果。 总之，通过使用Python编程语言来实现斗地主，可以让玩家在电脑上进行这种扑克牌游戏，提供了一种便捷、有趣的娱乐方式。同时，通过编写斗地主的代码，还可以提高自己的编程能力和逻辑思维能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值