首页手记扑克牌小程序，自己瞎写的。新手一枚，请多多指点!！

扑克牌小程序，自己瞎写的。新手一枚，请多多指点!！

标签：

Java

列表项

/*
    玩家类：因为类中定义的属性都为private，所有都定义相应的获取方法
*/

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

public class Player {
    private int id; //玩家ID
    private String name; //玩家姓名
    private List<Poker> pokers; //存放玩家手中的牌的容器
    //调用构造方法，初始化
    public Player(int id, String name) {
        this.id = id;
        this.name = name;
        this.pokers = new ArrayList<Poker>();
    } 
    //获取玩家ID的方法
    public int getId() {
        return id;
    }
    //获取玩家姓名的方法
    public String getName() {
        return name;
    }
    //获取存放玩家手里的牌的容器的方法
    public List<Poker> getPokers() {
        return pokers;
    }
    //重写hashCode()方法，自己随便写的，能用
    @Override
    public int hashCode() {
        return id * name.hashCode();
    }
    //重写equals方法
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (!(obj instanceof Player))
            return false;
        Player other = (Player) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    //获取玩家手中最大的牌的方法
    public Poker getMaxPokers() {
        Collections.sort(pokers); //先排序，由于重写了Poker类中compareTo()方法,下标为0的为最大值
        return pokers.get(0); //返回最大值
    }
}

/*
    扑克牌类，
        因为扑克牌是从2到A，有数字和字母，没想到能直接排序的方法
        所以就定义了两个int类型的属性：pointsID和colourID；
        pointsID 表示的数字为 0-12，对应扑克牌的，2-A
        colourID 根据不同的花色赋不同的数字，如：方片:1, 梅花:2, 红桃:3, 黑桃:4
        通过比较pointsID和colourID的大小来实现扑克牌的大小
*/
//该实现了Comparable接口
public class Poker implements Comparable<Poker> {
    private int pointsID;  //与牌的点数对应的数字
    private int colourID;  //与牌的花色对应的数字
    private String points; //牌的点数
    private String colour; //牌的花色
    //构造方法
    public Poker(int pointsID, int colourID, String points, String colour) {
        this.pointsID = pointsID;
        this.colourID = colourID;
        this.points = points;
        this.colour = colour;
    }
    //获取与点数对应的数字
    public int getpointsID() {
        return pointsID;
    }
    //获取与花色对应的数字
    public int getcolourID() {
        return colourID;
    }
    //重写toString()方法，输出 花色+点数
    public String toString() {
        return colour + points;
    }
    //重写Comparable类中compareTo()方法
    @Override
    public int compareTo(Poker p) {
        if (this.pointsID == p.pointsID) //如果点数一样，则比较花色
            return p.colourID - this.colourID; //这样定是降序排序，反着写就是升序排序，如：this.colourID - p.colourID;
        else
            return p.pointsID - this.pointsID; //比较花色，降序排序，也就是说容器中最大的下标为0
    }
    //下面的方法都没有用上
/*  public String getPoints() {
        return points;
    }

    public String getColour() {
        return colour;
    }

    @Override
    public int hashCode() {
        return pointsID + colourID + new String(points + colour).hashCode();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null)
            return false;
        if (!(o instanceof Poker))
            return false;
        Poker p = (Poker) o;
        if (this.points == null) {
            if (p.points != null)
                return false;
        } else {
            if (!(this.points.equals(p.points)))
                return false;
        }
        if (this.colour == null) {
            if (p.colour != null)
                return false;
        } else {
            if (!(this.colour.equals(p.colour)))
                return false;
        }
        return true;
    } */
}

/*
    启动类
*/

import java.util.Map;
import java.util.HashMap;
import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;
import java.util.Collections;
import java.util.Set;

class PlayerPoker {

    private List<Poker> sumLsit; //用来存放所有发出去的牌，主要是为了统计发出去最大的牌是哪张
    private Map<Integer, Player> players; //用来存放玩家
    private List<Poker> pokerList; //用来存放创建的牌
    private Scanner input;
    // 利用构造方法初始化属性
    public PlayerPoker() {
        this.players = new HashMap<Integer, Player>();
        this.pokerList = new ArrayList<Poker>();
        this.input = new Scanner(System.in);
        this.sumLsit = new ArrayList<Poker>();
    }
    //启动方法，个人习惯问题，main()方法中不喜欢写太多东西，所以都写这里了
    public void launch() {
        createPoker(); //创建扑克牌
        randomPoker(); //洗牌
        creatPlayer(); //创建玩家
        dealPoker(); // 发牌
        comparePoker(); //统计
    }
    //创建扑克牌
    public void createPoker() {
        System.out.println("-------------创建扑克牌...--------------");
        String[] s = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"}; //定义一个字符串数组

        int i = 0; //这里采用的是while循环
        int j = 0;
        while (i < 52) { //总共52张
            j = j % 13; //限制j的范围(0-12)，作为下标，为作为每张牌的点数，用来比较大小
            if (i < 13) //每个花色各13张牌，这里每种花色我都对应的赋了一个常量，通过比较常量来比较大小
                pokerList.add(new Poker(j, 1, s[j], "方片"));
            else if (i < 26) //每个花色各13张牌
                pokerList.add(new Poker(j, 2, s[j], "梅花"));
            else if (i < 39) //每个花色各13张牌
                pokerList.add(new Poker(j, 3, s[j], "红桃"));
            else //每个花色各13张牌
                pokerList.add(new Poker(j, 4, s[j], "黑桃"));
            i++;
            j++;
        }
        System.out.println("-------------扑克牌创建成功！--------------");
        System.out.println(pokerList); //输出，这样输出两边有 "[" " ]" 括号
    }
    //洗牌
    public void randomPoker() {
        System.out.println("-------------开始洗牌...--------------");
        Collections.shuffle(pokerList);  //调用Collections类中shuffle()方法就好了
        System.out.println("-------------洗牌结束！--------------");
    }
    //创建玩家
    public void creatPlayer() {
        System.out.println("-------------创建玩家...--------------");
        for (int i=0; i<2; i++) { //这所以写个循环，是为了方便修改玩家的人数，只需改一下循环的判断条件就好了
            System.out.println("请输入第" + (i+1) + "位玩家的ID和姓名：");
            int id = input(); //调用input()方法，对不合法的输入信息进行处理
            System.out.println("输入姓名：");
            String name = input.next(); //将输入信息存放在变量中
            Player player = new Player(id, name); //创建一个玩家
            players.put(id, player); //将创建的玩家存放到容器中
        }

        Set<Integer> keySet = players.keySet(); //调用HashMap中的keySet()方法，获取HashMap容器中所有的键的集合
        for (Integer id : keySet) {
            System.out.println("----欢迎玩家：" + players.get(id).getName());
        }
    } 
    // 发牌
    public void dealPoker() {
        System.out.println("-------------开始发牌...--------------");
        Set<Integer> keySet = players.keySet(); ////调用HashMap中的keySet()方法，获取HashMap容器中所有的键的集合

        int i = 0; //i作为从pokerList容器中发牌的下标 从0开始
        int j = 0; //j表示要发多少轮，可以随便修改，但不要超过pokerList中的容量，即：玩家数量*发牌轮数 不能大于51(0-51),否则报下标越界异常
        while (j < 2) { //为了程序的健壮性，本来应该对可能抛出的下标越界异常进行处理的，由于本人比较懒，就没写处理代码了，这里提示一下各位
            for (Integer id : keySet) { //每循环一轮，players容器中的所有玩家各拿一张牌
                players.get(id).getPokers().add(pokerList.get(i));
                System.out.println("----玩家：" + players.get(id).getName() + "-拿牌");
                sumLsit.add(pokerList.get(i)); //存放玩家所拿的牌，都存入到sumList容器中，方便找出最大的牌,下面102行和110行会用到
                i++;
            }
            j++; 
        }
        System.out.println("-------------发牌结束...--------------");
    }
    // 统计
    public void comparePoker() {
        System.out.println("-------------开始游戏...--------------");
        Collections.sort(sumLsit); //对所有玩家所拿的牌进行排序，由于在Poker类中重写了compareTo()方法，下标为0的为最大的牌
        String winPlayer = ""; //定义一个字符串变量，用来存放获胜玩家的姓名

        Set<Integer> keySet = players.keySet();//调用HashMap中的keySet()方法，获取HashMap容器中所有的键的集合
        for (Integer id : keySet) { //调用玩家类Player中的getMaxPokers()方法获取该玩家手中最大的牌
            System.out.println("玩家：" + players.get(id).getName() + "最大的手牌为：" 
                + players.get(id).getMaxPokers());
            //sumLsit.get(0)为所有玩家最大的牌，通过它与每一位玩家手中最大的牌进行比较，如果是同一张，则返回该玩家的名字
            if (sumLsit.get(0).equals(players.get(id).getMaxPokers())) {
                winPlayer = players.get(id).getName(); //将该玩家的名字赋给前面定义好的变量
            }
        }

        System.out.println("-------------玩家：" + winPlayer + "获胜！--------------");       
        System.out.println("玩家各自的手牌为：");
        for (Integer id : keySet) { //循环输出每个玩家手中所有的牌
            System.out.print(players.get(id).getName() + "："); //输出玩家姓名
            System.out.println(players.get(id).getPokers()); //输出玩家手牌
        }
    }
    // 对从键盘输入的信息进行处理
    public int input() {
        while (true) {
            System.out.println("输入ID:");
            int k;
            try {
                k = input.nextInt();
                return k; //如果输入为int类型，则返回输入的值
            } catch (Exception e) {
                System.out.println("请输入整数类型的ID!"); //如果输入不是int类型，重新输入
                input = new Scanner(System.in);
            }
        }
    }
}
// 启动类
public class TestPoker {
    public static void main(String[] args) {
        new PlayerPoker().launch(); //调用启动方法
    }
}

点击查看更多内容