java基礎——輕輕松松控制臺斗地主-有解無憂

實作在控制臺斗地主

今天給大家一起分享一下，最近回頭學習java基礎實作的一個控制臺版的斗地主，先給大家簡單看一下要求：
有地主，有2個農民，地主有額外3張牌，
游戲開始時，顯示地主的牌，并從控制臺接收要出的牌，地主出牌后，
農民1顯示牌，并從控制臺接收要出的牌，以此類推，
如果地主贏了，提示地主勝利，如果有一個農民勝利了，就提示農民勝利，

1.先理清邏輯

在開始敲代碼之前，我們第一步一定不是急著動手，而是需要分析一下，我們做的這個專案，它一步一步的應該怎么來操作和完成，理清思路之后，其實剩下的就都是水到渠成的了！初學的同學不信可以先不看下面的分析，來直接寫這個專案，我相信中間你肯定是會遇到問題的，
好，那我們在看到題目之后，進行簡單的分析，

需要創建一個牌類（Poke），它有牌號（pokecard）、花色（pokecolor）這兩個基本屬性，因為這兩個屬性是固定不改變的，所以在定義的時候我們可以把它們用final修飾符修飾，其次它還需要一個生成一副牌的方法makepoke()，以便于之后呼叫，隨后我們還需要有一個排序的方法，來進行一個從大到小的顯示，也方便在發牌之后重新進行排序，這里就還有一個自定義的比較器介面MyComparator，
需要創建一個人物類（Person），它有一副牌（Poke）、人名(name)、是否是地主（islandlord）這三個基本屬性有一個出牌的方法（sendpoke），
需要創建一個斗地主的工具類（Fightlandlords），它有牌（Poke）、人（person）兩個基本屬性， 有一個選地主的方法（changelandlord）、一個洗牌的方法(shufflecards)、一個發牌的方法（Licensing）、一個打牌的方法（startpoke），

按照思路一步步實作

我們先實作牌類，具體代碼如下：

package com.dun.palypoke;
import java.util.ArrayList;
import java.util.Collections;

/*
牌類
有牌號、花色兩個屬性；
有生成一副牌（54張牌）的方法；
實作比較器介面，便于整理牌時從小到大排序，
構造方法私有化，只能通過生成一副牌方法來獲得牌，
*/
public class Poke{
private static final String[] pokecard = {“3”, “4”, “5”, “6”, “7”, “8”, “9”, “10”, “J”, “Q”, “K”, “A”, “2”, “小王”, “大王”}; //牌號
private static final String[] pokecolor = {“?”, “?”, “?”, “?”}; // 牌的花色

public String[] getPokecard() {
    return pokecard;
}

public String[] getPokecolor() {
    return pokecolor;
}

private Poke() {

}
/*
      生成牌的方法， 回傳一副牌
    */
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++) {
            Collections.addAll(poke, pokecolor[j] + pokecard[i]);
        }
    }
    /*
    手動添加大小王
     */
    poke.add(pokecard[pokecard.length - 2]);
    poke.add(pokecard[pokecard.length - 1]);
    return poke;
	}
}

在makepoke（）方法中，我使用了兩層for回圈，第一個用來控制牌號，第二個用來控制花色，因為大小王不涉及到花色，所以我在最后一步進行手動的添加，最后將這副牌回傳，因為我的構造方法設定為私有，所以我將makepoke方法加入了static修飾詞，這樣只能通過類名點的方式呼叫，
新建一個Test測驗類，測驗一下，
在這里插入圖片描述
看到運行完成，我們的第一個類就完成了！

隨后我們撰寫第二個類——人物類，

package com.dun.palypoke;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Scanner;

/*
創建人物類：
1.有一副牌(集合/陣列)、名字、是否是地主三個屬性；
2.有出牌的方法，出牌前先在控制臺列印出所有的牌，再從控制臺接受出的牌，并出牌，
3.有理牌的方法，整理后牌按從小到大方式排序，

 */
public class Person {
    private ArrayList poke = new ArrayList();         //一副牌
    private String name;                             //名稱
    private boolean islandlord;                     //是否是地主

    public  Scanner sc = new Scanner(System.in);

    public ArrayList getPoke() {
        return poke;
    }

    public Person() {

    }
    public  Person(String name){
       this.name = name;
    }

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

    public String getName() {
        return name;
    }

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

    public boolean isIslandlord() {
        return islandlord;
    }

    public void setIslandlord(boolean islandlord) {
        this.islandlord = islandlord;
    }

    /*
        出牌     區域變數list的作用是當用戶出多張牌時，通過n++來表示用戶出的牌和他手上的牌是否全部存在，如果存在，就全部洗掉，
         */
    public ArrayList sendpoke(ArrayList poke){
        System.out.println(poke);
        ArrayList list = new ArrayList<>();         //臨時變數
        for (int i = 0; i < poke.size(); i++) {
            list.add(poke.get(i));
     }
        System.out.println("請輸入要出的牌(不用輸入花色,出多張牌用,分開、要不起或不要請輸入N):");
        String usersc = sc.next();
        if(usersc.equalsIgnoreCase("n")){
            System.out.println("要不起");
            return this.poke;
        }
        String[] spoke = usersc.split(",");

        int n = 0;  //計數
        int i = 0;

        while(i<spoke.length) {
            Iterator iterator = list.iterator();
            while (iterator.hasNext()){
                String next = (String) iterator.next();
                if (next.contains(spoke[i])){
                    iterator.remove();
                    i = 0;
                    n++;
                    break;
                }
            }
            i++;
        }
        if(n == spoke.length){
           this.poke = list;
            System.out.println("出牌成功");
        }
        else{
            System.out.println("你沒有這些牌,給我這渾水摸魚呢?");
        }
        return this.poke;
    }
}

人物類定義完基本屬性后，添加get、set方法之后我們就只需要進行出牌方法（sendpoke）的撰寫了

這里一開始我把poke給列印了一遍，因為斗地主工具類我們還沒有撰寫，所以這里列印出來的poke集合肯定是整副牌，不過不用擔心，等我們把工具類寫完之后，這里訪問的poke就是其中一個用戶的牌了，

我定義了一個臨時變數，用來進行洗掉操作，因為涉及到出多張牌的情況，如何不定義這個臨時變數，用用戶自己的牌去進行洗掉操作，就會出現例外，比如，**用戶出3個6帶一個4，可是用戶的牌只有三個六，我在查找到這3個六之后已經把它洗掉了，后面的4沒有找到，雖然也是會輸出”你沒有這些牌,給我這渾水摸魚呢?"，但是用戶的牌中的三個六我卻已經給它洗掉了，這很顯然不符合我們的邏輯，**所以我定義了臨時的一個集合變數，只有當將用戶輸入的所有數都遍歷完了之后，通過n 的值是否與spoke.length相等來將list的值重新賦值給 poke ，這樣就完美的解決了這個問題！

在這里插入圖片描述

在Test類中測驗，可以看到，我們的人物類（Person）也完成咯！

最后我們來完成斗地主的工具類（Fightlandlord）：

package com.dun.palypoke;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

/*
斗地主類
1.有牌（集合）和人（集合）兩個屬性；有一個構造方法，構造方法要傳入3個人，一副牌；
2.有洗牌的方法，用于重排所有的牌，
3.有發牌的方法，為3個用戶按順序發牌，同時地主獲得最后3張牌，
4.有開始方法，開始后地主先出牌，農1出牌，農2出牌....如果地主牌先出完，列印地主勝利；如果農民有一個人先勝利，則列印農民勝利，

 */
public class Fightlandlords {
    public ArrayList poke ;                 //獲取一副牌

    public  Person p1;                                   //人1
    public  Person p2;                                   //人2
    public  Person p3;                                   //人3

    public Fightlandlords(ArrayList poke, Person p1,Person p2,Person p3) {
        this.poke = poke;
        this.p1 = p1;
        this.p2 = p2;
        this.p3 = p3;
    }

    /*
    選地主
     */
    public  void changelandlord(){
        Random random = new Random();
        int n = random.nextInt(3)+1;
        if(n == 1){
            System.out.println(p1.getName()+"成為地主");
            p1.setIslandlord(true);
        }else if(n == 2){
            System.out.println(p2.getName()+"成為地主");
            p2.setIslandlord(true);
        }
        else{
            System.out.println(p3.getName()+"成為地主");
            p3.setIslandlord(true);
        }
    }
    /*
    洗牌
     */
    public ArrayList shufflecards(){
        Collections.shuffle(poke);
        return poke;
    }

    /*
    發牌
     */
    public void  Licensing() {
        changelandlord();
        if (p1.isIslandlord()){
            p1.getPoke().add(poke.get(poke.size()-3));
            p1.getPoke().add(poke.get(poke.size()-2));
            p1.getPoke().add(poke.get(poke.size()-1));

        }
        if (p2.isIslandlord()){
            p2.getPoke().add(poke.get(poke.size()-3));
            p2.getPoke().add(poke.get(poke.size()-2));
            p2.getPoke().add(poke.get(poke.size()-1));

        }
        if (p3.isIslandlord()){
            p3.getPoke().add(poke.get(poke.size()-3));
            p3.getPoke().add(poke.get(poke.size()-2));
            p3.getPoke().add(poke.get(poke.size()-1));

        }
        for (int i = 0; i < poke.size() - 3; i += 3) {
            if (p1.isIslandlord()) {
                p1.getPoke().add(poke.get(i));
                p2.getPoke().add(poke.get(i + 1));
                p3.getPoke().add(poke.get(i + 2));
            }
            if(p2.isIslandlord()){
                p2.getPoke().add(poke.get(i));
                p3.getPoke().add(poke.get(i+1));
                p1.getPoke().add(poke.get(i+2));
            }
            if(p3.isIslandlord()){
                p3.getPoke().add(poke.get(i));
                p1.getPoke().add(poke.get(i+1));
                p2.getPoke().add(poke.get(i+2));
            }
        }

        /*
        從小到大排序
         */
        Collections.sort(p1.getPoke(),new MyComparator());
        Collections.sort(p2.getPoke(),new MyComparator());
        Collections.sort(p3.getPoke(),new MyComparator());
    }

    /*
    開始打牌
    */
    public void startpoke(){
        if (p1.isIslandlord()){
            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.isIslandlord()){
            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.isIslandlord()){
            while (true){
                System.out.print("地主出牌:");
                p3.sendpoke(p1.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;
                }
            }

        }
    }

}

給大家一一解釋一下這些方法，第一個很簡單，changelandlord（）通過創建一個1-3的亂數來選擇地主，并將值傳給對應人物的setIslandlord方法！

第二個洗牌，我直接呼叫了Collections的API中的shuffle方法，它可以幫我們完成隨機排序，大家也可以自己寫，這個shuffle方法的底層邏輯也是通過創建亂數來實作了！我這個偷了一下懶，哈哈~

第三個發牌，我先把地主選出來，然后先把屬性地主的最后三張牌發給他，隨后通過for回圈給三個玩家依次發牌，發完一輪之后i+3，最后的Collections.sort方法中，將每個玩家的牌按照我們平時斗地主，3最小，2最大，A比2小的方法通過Mycomparator()進行了重寫，這是我比較器的原始碼：

package com.dun.palypoke;

import java.util.Comparator;

/*
自定義排序方法
 */
public class MyComparator implements Comparator<String> {
    @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;
    }
}

主要比較它們第一個字符的Ascill碼表，因為除了大小王，其他牌下標0表示的是花色，所以比較下標的第一位，

這樣我們整個專案就完成咯，給大家看看運行的效果~
在這里插入圖片描述
好咯，咱們專案就寫到這兒，中間是還有一些小細節的，大家有問題的可以在評論區聯系我哈，這個專案用陣列也是可以做的哈，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/278454.html

標籤：java

上一篇：Socket和ServerSocket基本用法（建立網路通訊）

下一篇：Java實作冒泡排序（詳解）