【Java 基础篇】Java 实现模拟斗地主游戏

灰太狼 2023-10-16 14:29 112阅读 0赞

![在这里插入图片描述][d39655a663224c969225de140baf49af.png]

欢迎阅读本篇博客，在这篇博客中，我们将详细讲解如何使用Java编写一个简单的模拟斗地主游戏。这个项目将帮助您了解Java编程中的一些基本概念，如面向对象编程、集合框架的使用、随机数生成等。

### 引言 ###

斗地主是一种非常受欢迎的纸牌游戏，通常由3名玩家参与。在这个游戏中，玩家需要出牌并尽量在每一轮中获得尽可能多的分数。每一轮中都有一个玩家充当地主，而其他两名玩家则是农民。本项目的目标是通过Java代码模拟这个游戏并让您了解Java编程的基本原理。

### 项目概述 ###

在本项目中，我们将创建一个简化版的斗地主游戏，其中包括一副扑克牌、三名玩家和一些游戏逻辑。我们将使用Java编程语言来实现整个项目。这个项目将帮助您巩固Java编程中的一些关键概念，如类、对象、继承、集合等。

### 游戏规则 ###

在斗地主游戏中，一副扑克牌包含54张牌，其中包括52张普通牌和两张大小王。游戏的基本规则如下：

1.  游戏开始时，一副牌被洗牌并分发给三名玩家，每名玩家17张牌，地主多一张。
2.  地主由系统随机选出，地主的任务是在游戏中尽量多地获得分数。
3.  游戏进行时，玩家按照规定的出牌规则出牌，其他玩家需要在规定的时间内选择是否要跟牌。
4.  游戏的目标是尽量在每一轮中获得尽可能多的分数，分数根据出牌的牌型和牌面大小来计算。
5.  游戏结束后，根据玩家的得分确定胜负。

### 项目结构 ###

在开始编写代码之前，让我们先确定项目的结构。我们将创建以下类来组织我们的项目：

1.  **Card（卡牌类）** \- 表示一张扑克牌。
2.  **Player（玩家类）** \- 表示一名玩家，包括手中的牌和玩家的基本信息。
3.  **Game（斗地主游戏类）** \- 表示整个游戏，包括游戏的规则和逻辑。

现在，让我们逐步实现这些类，从卡牌类开始。

### 实现步骤 ###

#### 创建卡牌类 ####

首先，我们需要创建一个`Card`类来表示一张扑克牌。每张牌都有花色和点数，所以我们需要定义这两个属性。以下是`Card`类的基本结构：

public class Card {
        
        private String suit; // 花色
        private String rank; // 点数
    
        // 构造函数
        public Card(String suit, String rank) {
        
            this.suit = suit;
            this.rank = rank;
        }
    
        // Getter```java
        public String getSuit() {
        
            return suit;
        }
    
        public String getRank() {
        
            return rank;
        }
    
        // 覆盖toString方法，用于打印牌的信息
        @Override
        public String toString() {
        
            return rank + " of " + suit;
        }
    }

`Card`类有两个私有属性：`suit`（花色）和`rank`（点数）。构造函数用于初始化这两个属性。我们还提供了`getSuit`和`getRank`方法，以及覆盖了`toString`方法，用于返回牌的字符串表示。

#### 创建玩家类 ####

接下来，我们将创建一个`Player`类来表示一名玩家。每名玩家都有一个唯一的标识符、手中的牌和当前的得分。以下是`Player`类的基本结构：

import java.util.ArrayList;
    import java.util.List;
    
    public class Player {
        
        private int id; // 玩家标识符
        private List<Card> hand; // 手中的牌
        private int score; // 当前得分
    
        // 构造函数
        public Player(int id) {
        
            this.id = id;
            this.hand = new ArrayList<>();
            this.score = 0;
        }
    
        // Getter和Setter方法
        public int getId() {
        
            return id;
        }
    
        public List<Card> getHand() {
        
            return hand;
        }
    
        public int getScore() {
        
            return score;
        }
    
        public void setScore(int score) {
        
            this.score = score;
        }
    
        // 添加一张牌到玩家手中
        public void addCard(Card card) {
        
            hand.add(card);
        }
    
        // 从玩家手中移除一张牌
        public void removeCard(Card card) {
        
            hand.remove(card);
        }
    
        // 覆盖toString方法，用于打印玩家信息
        @Override
        public String toString() {
        
            return "Player " + id;
        }
    }

`Player`类有三个私有属性：`id`（玩家标识符）、`hand`（手中的牌）和`score`（当前得分）。构造函数用于初始化这些属性。我们提供了一些方法来获取和设置属性，以及添加和移除手中的牌。覆盖的`toString`方法用于返回玩家的字符串表示。

#### 创建斗地主游戏类 ####

现在，让我们创建`Game`类来表示整个斗地主游戏。`Game`类将包含游戏的规则和逻辑。以下是`Game`类的基本结构：

import java.util.*;
    import java.util.stream.Collectors;
    
    public class Game {
        
        private List<Card> deck; // 牌堆
        private List<Player> players; // 玩家列表
        private Player landlord; // 地主
        private List<Card> landlordCards; // 地主的底牌
    
        // 构造函数
        public Game() {
        
            // 初始化牌堆
            initializeDeck();
            
            // 初始化玩家
            initializePlayers();
            
            // 洗牌
            shuffleDeck();
            
            // 发牌
            dealCards();
        }
    
        // 初始化牌堆，创建一副包含54张牌的扑克牌
        private void initializeDeck() {
        
            deck = new ArrayList<>();
            String[] suits = {
        "Spades", "Hearts", "Diamonds", "Clubs"};
            String[] ranks = {
        "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King", "Ace"};
            
            for (String suit : suits) {
        
                for (String rank : ranks) {
        
                    deck.add(new Card(suit, rank));
                }
            }
            
            // 添加大小王
            deck.add(new Card("Joker", "Red"));
            deck.add(new Card("Joker", "Black"));
        }
    
        // 初始化玩家，创建三名玩家
        private void initializePlayers() {
        
            players = new ArrayList<>();
            for (int i = 1; i <= 3; i++) {
        
                players.add(new Player(i));
            }
        }
    
        // 洗牌
        private void shuffleDeck() {
        
            Collections.shuffle(deck);
        }
    
        // 发牌，每名玩家发17张牌
        private void dealCards() {
        
            for (int i = 0; i < 51; i++) {
        
                players.get(i % 3).addCard(deck.get(i));
            }
            
            // 底牌
            landlordCards = deck.subList(51, 54);
        }
    
        // 获取地主
        public Player getLandlord() {
        
            return landlord;
        }
    
        // 设置地主
        public void setLandlord(Player landlord) {
        
            this.landlord = landlord;
        }
    
        // 获取地主的底牌
        public List<Card> getLandlordCards() {
        
            return landlordCards;
        }
    }

`Game`类有四个私有属性：`deck`（牌堆）、`players`（玩家列表）、`landlord`（地主）和`landlordCards`（地主的底牌）。构造函数用于初始化牌堆、玩家和进行洗牌和发牌操作。还提供了一些方法来获取和设置地主和底牌。

#### 实现洗牌和发牌 ####

在`Game`类中，我们使用`initializeDeck`方法初始化牌堆，然后使用`shuffleDeck`方法洗牌，最后使用`dealCards`方法发牌。现在，让我们继续实现这些方法。

// 洗牌
    private void shuffleDeck() {
        
        Collections.shuffle(deck);
    }
    
    // 发牌，每名玩家发17张牌，地主多一张
    private void dealCards() {
        
        for (int i = 0; i < 51; i++) {
        
            players.get(i % 3).addCard(deck.get(i));
        }
        
        // 底牌
        landlordCards = deck.subList(51, 54);
    }

这些方法很简单，`shuffleDeck`方法使用`Collections.shuffle`方法来随机打乱牌堆的顺序，`dealCards`方法将牌分发给玩家和地主。

#### 实现游戏逻辑 ####

在斗地主游戏中，有很多复杂的规则和逻辑，包括出牌规则、跟牌规则、牌型判断等。在这篇博客中，由于篇幅限制，我们只实现了游戏的基本结构，您可以根据自己的兴趣和需求继续完善游戏的逻辑。

### 游戏运行 ###

为了运行斗地主游戏，您可以创建一个主类，初始化游戏对象，然后按照游戏规则逐步进行游戏逻辑的实现。您可以使用控制台来与玩家交互，获取玩家的出牌和跟牌操作，并根据游戏规则来判断胜负。

### 总结 ###

通过这个简单的模拟斗地主游戏项目，我们学习了如何使用Java编程语言来创建类、对象，实现洗牌和发牌操作，以及设计基本的游戏规则和逻辑。这个项目只是一个开始，您可以继续扩展它，添加更多的功能和规则，以创建一个完整的斗地主游戏。

希望这篇博客能帮助您更好地理解Java编程的基本原理，如果您有任何问题或建议，请随时与我们分享。祝您编程愉快！

<table> 
 <tbody> 
  <tr> 
   <td> <strong><font>作者信息</font></strong><br> <br> <font> 作者 ： 繁依Fanyi</font><br> <font>CSDN：</font> <a href="https://blog.csdn.net/qq_21484461?spm=1000.2115.3001.5343" rel="nofollow"><font>https://techfanyi.blog.csdn.net</font></a><br> <font>掘金：</font><a href="https://juejin.cn/user/4154386571867191" rel="nofollow"><font>https://juejin.cn/user/4154386571867191</font></a> </td> 
  </tr> 
 </tbody> 
</table>

[d39655a663224c969225de140baf49af.png]: https://img-blog.csdnimg.cn/d39655a663224c969225de140baf49af.png