JavaSE 练习对面向对象思想、单列集合、双列集合的综合运用 - 斗地主

一、整体思路

首先斗地主我们需要三个玩家，三个玩家分别有拿牌、清理牌、和看牌三个方法。同时还需要一个荷官类，荷官有准备牌、洗牌、发牌、获取地主的功能。当然最重要的是有一个游戏的入口

二、荷官类功能实现思路

1、准备牌

首先需要将四种不同花色的牌组合成一盒完整的扑克，同时在玩家中需要有清理牌的功能，所以我们将每个牌对应一个int类型的编号

2、洗牌

使用Collections中的shuffle方法对集合中元素进行乱序

3、发牌

首先当下标>=51时将这三张牌作为底牌，当下标%3==0时我们发给第一位玩家，下标%3==1时我们发给第二位玩家，剩下的就都是第三位玩家的牌

4、获取地主功能

我们使用Java 中实现好的Random类来获取一个随机数当然范围不能超过集合大小，拿到随机数之后。我们看三位玩家牌对应的编号中是否包含这个随机数，如果包含就是谁的地主

注意：在荷官中，如何去准备牌、洗牌、获取地主这些都不能让外界访问，唯一外界能够访问的只有荷官发牌的功能，所以其他三个功能全部需要私有化

荷官类代码如下

package cn.itcast.javaeeday09level01;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Random;
import java.util.Set;

/**
*
* @author 大家都说名字长不会被发现
*  荷官类
*/
public class Dealer {
private String name;
private int number;

public int getNumber() {
return number;
}

public void setNumber(int number) {
this.number = number;
}

public Dealer() {
super();
// TODO Auto-generated constructor stub
}

public Dealer(String name,int number) {
super();
this.name = name;
this.number = number;
}

public String getName() {
return name;
}

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

/**
* 发牌
*/
public void Licensing(Gambler gamblerOne,Gambler gamblerTwo,Gambler gamblerThree) {

System.out.println("编号为"+number+"的"+name+"荷官正在准备扑克中......");
//准备牌
HashMap<Integer,String> pokers = ReadyPoker();

System.out.println("正在洗牌......");
//洗牌
ArrayList<Integer> Nos = washPoker(pokers);

//发牌
System.out.println("正在发牌......");
//定义三个玩家牌集合，底牌集合
ArrayList<Integer> cards = new ArrayList<>();
ArrayList<Integer> playerOnePoker = new ArrayList<>();
ArrayList<Integer> playerTwoPoker = new ArrayList<>();
ArrayList<Integer> playerThreePoker = new ArrayList<>();

for(int i = 0; i < Nos.size(); i++) {
if (i>=51) {
cards.add(Nos.get(i));
}else {
if (i%3 == 0) {
playerOnePoker.add(Nos.get(i));
}else if (i%3 == 1) {
playerTwoPoker.add(Nos.get(i));
}else {
playerThreePoker.add(Nos.get(i));
}
}
}
//获取地主并将底牌给地主
selectLandlord(playerOnePoker,playerTwoPoker,playerThreePoker,cards,pokers);

//查看玩家的牌

if (gamblerOne instanceof PlayerOne && gamblerTwo instanceof PlayerTwo && gamblerThree instanceof PlayerThree) {
PlayerOne one = (PlayerOne) gamblerOne;
one.setNunbers(playerOnePoker);
one.setPokers(pokers);
one.setPlayerNumber("玩家一");
one.seePokers();
PlayerTwo two = (PlayerTwo)gamblerTwo;
two.setNunbers(playerTwoPoker);
two.setPokers(pokers);
two.setPlayerNumber("玩家二");
two.seePokers();
PlayerThree three = (PlayerThree)gamblerThree;
three.setNunbers(playerThreePoker);
three.setPokers(pokers);
three.setPlayerNumber("玩家三");
three.seePokers();

}
//查看底牌
System.out.print("底牌为：");
for (Integer no : cards) {
String poker = pokers.get(no);
System.out.print(poker+"  ");
}

}
/**
*
* @param playerOnePoker
* @param playerTwoPoker
* @param playerThreePoker
* @param cards
* @param pokers
*
* 获取地主
*/
private void selectLandlord(ArrayList<Integer> playerOnePoker, ArrayList<Integer> playerTwoPoker,
ArrayList<Integer> playerThreePoker, ArrayList<Integer> cards, HashMap<Integer, String> pokers) {
// TODO Auto-generated method stub

//获取所有的键
Set<Integer> keySet = pokers.keySet();
ArrayList<Integer> keylists = new ArrayList<>();
keylists.addAll(keySet);

//获取随机数
Random random = new Random();
int randomNumber = random.nextInt(keylists.size());

//获取随机数位置的元素
Integer poker = keylists.get(randomNumber);

if (playerOnePoker.contains(poker)) {
System.out.println("第一位玩家为地主");
playerOnePoker.addAll(cards);
}else if (playerTwoPoker.contains(poker)) {
System.out.println("第二位玩家为地主");
playerTwoPoker.addAll(cards);
}else {
System.out.println("第三位玩家为地主");
playerThreePoker.addAll(cards);
}

}
/**
*
* @return
*
* 准备牌
*/
private HashMap<Integer, String> ReadyPoker() {
// TODO Auto-generated method stub
//定义花色集合
ArrayList<String> colors = new ArrayList<>();
//定义数字集合
ArrayList<String> numbers = new ArrayList<>();

//向集合中添加元素
Collections.addAll(colors, "♦","♣","♠","♥");
Collections.addAll(numbers, "3","4","5","6","7","8","9","10","J","Q","K","A","2");

//定义牌盒
HashMap<Integer, String> pokers = new HashMap<>();

//向牌盒中添加牌，带编号添加。

//定义编号
int No = 1;
for (String number : numbers) {
for (String color : colors) {
pokers.put(No++, color+number);
}
}

//最后向牌盒中添加大王和小王
pokers.put(No++, "��");
pokers.put(No++, "☠");

//返回牌盒
return pokers;
}

/**
*
*
* @param pokers
* @return
*
* 洗牌
*/
private ArrayList<Integer> washPoker(HashMap<Integer, String> pokers) {
// TODO Auto-generated method stub

//获取Map中所有的Key(编号)
Set<Integer> numbersSet = pokers.keySet();

//创建List集合,并将set集合添加到list集合中

ArrayList<Integer> numbersList = new ArrayList<>();
numbersList.addAll(numbersSet);

//洗牌
Collections.shuffle(numbersList);

//返回编号集合
return numbersList;
}
}

三、玩家父类赌徒类的实现思路

1、拿牌

拿牌功能需要传入玩家牌的编号，然后根据编号去找对应的牌

2、清理牌

对集合中牌的标号进行排序，同样是使用的Collections中的sort方法来进行排序

3、看牌

打印玩家清理后牌集合的内容

赌徒类代码如下

package cn.itcast.javaeeday09level01;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;

/**
*
* @author 大家都说名字长不会被发现
*  赌徒类
*/
public abstract class Gambler {

private ArrayList<Integer> nunbers;
private HashMap<Integer, String> pokers;
private String playerNumber;

public ArrayList<Integer> getNunbers() {
return nunbers;
}

public void setNunbers(ArrayList<Integer> nunbers) {
this.nunbers = nunbers;
}

public HashMap<Integer, String> getPokers() {
return pokers;
}

public void setPokers(HashMap<Integer, String> pokers) {
this.pokers = pokers;
}

public String getPlayerNumber() {
return playerNumber;
}

public void setPlayerNumber(String playerNumber) {
this.playerNumber = playerNumber;
}

public Gambler(ArrayList<Integer> nunbers, HashMap<Integer, String> pokers, String playerNumber) {
super();
this.nunbers = nunbers;
this.pokers = pokers;
this.playerNumber = playerNumber;
}

public Gambler() {
super();
// TODO Auto-generated constructor stub
}

//看牌方法
public void seePokers() {

//将玩家摸到 的牌打印到控制台
ArrayList<String> takePoker = takePoker(nunbers, pokers);
System.out.println(getPlayerNumber()+"的牌："+takePoker);
}

//清理牌
public ArrayList<Integer> cleanUpAfterpokers(ArrayList<Integer> numbers){

//对拿到的牌进行排序
Collections.sort(numbers);

return numbers;
}

//拿牌
public ArrayList<String> takePoker(ArrayList<Integer> nunbers,HashMap<Integer, String> pokers){

//创建一个新的集合
ArrayList<String> playerSignificantpoker = new ArrayList<>();

//调用清理牌的方法，对每个牌的编号进行排序
ArrayList<Integer> cleanUpAfterpokers = cleanUpAfterpokers(nunbers);

//根据编号去那牌
for (Integer number : cleanUpAfterpokers) {
String poker = pokers.get(number);
playerSignificantpoker.add(poker);

}
return playerSignificantpoker;
}
}

四、玩家类的实现思路

玩家类的实现就相对来说较为简单了，只需要定义三个玩家类来继承赌徒类就可以了，所有的功能父类都以实现。

三个玩家类的代码如下

package cn.itcast.javaeeday09level01;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
/**
*
* @author 大家都说名字长不会被发现
* 玩家一
*/
public class PlayerOne extends Gambler{

public PlayerOne() {
super();
// TODO Auto-generated constructor stub
}

public PlayerOne(ArrayList<Integer> nunbers, HashMap<Integer, String> pokers, String playerNumber) {
super(nunbers, pokers, playerNumber);
// TODO Auto-generated constructor stub
}

}

package cn.itcast.javaeeday09level01;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
/**
*
* @author 大家都说名字长不会被发现
* 玩家二
*/
public class PlayerTwo extends Gambler{

public PlayerTwo() {
super();
// TODO Auto-generated constructor stub
}

public PlayerTwo(ArrayList<Integer> nunbers, HashMap<Integer, String> pokers, String playerNumber) {
super(nunbers, pokers, playerNumber);
// TODO Auto-generated constructor stub
}

}

package cn.itcast.javaeeday09level01;

import java.util.ArrayList;
import java.util.HashMap;
/**
*
* @author 大家都说名字长不会被发现
*  玩家三
*/
public class PlayerThree extends Gambler{

public PlayerThree() {
super();
// TODO Auto-generated constructor stub
}

public PlayerThree(ArrayList<Integer> nunbers, HashMap<Integer, String> pokers, String playerNumber) {
super(nunbers, pokers, playerNumber);
// TODO Auto-generated constructor stub
}

}

五、游戏入口

创建三个玩家对象，创建荷官类对象调用荷官类发牌功能，将三个玩家传入。

游戏入口代码如下

package cn.itcast.javaeeday09level01;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

/**
*
* @author 大家都说名字长不会被发现
*  斗地主
*/
public class ThreePokerPlay {
public static void main(String[] args) {

//创建荷官对象
Dealer dealer = new Dealer("陈尔高",27);

//玩家对象
PlayerOne one = new PlayerOne();

PlayerTwo two = new PlayerTwo();

PlayerThree three = new PlayerThree();

//调用发牌功能
dealer.Licensing(one,two,three);

}
}