Java基础--斗地主项目

业务需求：实现做牌、洗牌、发牌、看牌。

目录

做牌与洗牌

发牌与看牌、排序

---

做牌与洗牌

代码逻辑：创建一个room类，在main方法中每实例化一个room类，等价于开了一个游戏房间，一局游戏开始

这里充分体现了构造器的优越性。我们可以在实例化一个类的时候，可以顺带着完成对象的初识化，而无需在main方法另写代码对对象进行赋值以及调用必要的方法。

构造器的优越性：在实例化类时，同时完成对象的初始化。初始化的东西即为该类所有的对象都要执行的代码。

做牌时，首先要清楚每一张牌有两种属性，因此一副牌即是牌类所有对象的集合

洗牌 ：洗牌的操作充分发挥了java众多api的优越性，我们无需要自己再写算法去打乱集合，只需要调用Collections.shuffle()即可

public class card {
    private String num;
    private int size;

    public String getNum() {
        return num;
    }
//    toString方法是Java中的一个常用方法，它用于返回对象的字符串表示。当我们打印（sout）一个对象时，
//    本质上调用的就是对象的toString方法。
//    在Java中，toString方法默认定义于object类中，它返回一个由类名和对象的哈希码组成的字符串。
//    我们可以重写toString方法，以便返回更有意义的对象字符串表示。
    @Override
    public String toString() {
        return "card{" +
                "num='" + num + '\'' +
                ", size=" + size +
                '}';
    }

    public void setNum(String num) {
        this.num = num;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }
}

public class room {
    private List<card> cards = new ArrayList<>() ;

    public List<card> getCards() {
        return cards;
    }

    public void setCards(List<card> cards) {
        this.cards = cards;
    }

    //一进入房间，就自动创建好一副牌并完成洗牌,为了完成这个初始化，需要调用无参构造器,此即为无参构造器的作用
    public room(){
        String[] strings= {"3","4","5","6","7","8","9","10","A","J","Q","K","2"};
        for(int i = 0 ; i < 4;++i){
            int size = 0 ;
            for (String string : strings) {
                card card = new card();
                card.setNum(string);
                card.setSize(size);
                ++size;
                cards.add(card);
            }
        }
        card joker = new card();
        joker.setNum("joker");
        joker.setSize(13);
        cards.add(joker);
        card king = new card();
        joker.setNum("king");
        joker.setSize(14);
        cards.add(king);
        //洗牌
        Collections.shuffle(cards);

    }




}

发牌与看牌、排序

房间已经创好，接下来便是玩家入场，并且系统自动给他们发牌。

下述代码中，使用了一个Collections.sort（）进行排序。

该排序接口的使用有两种方式：

1.确保所要排序集合中的元素实现了Comparable接口

2.在Collections.sort（）额外传一个Comparator对象参数，来指定排序规则，这里一般直接定义一个匿名内部类（父类为Comparator对象，无具体类名以及对象名）

Collections.sort(Rain, new Comparator<card>() {
            @Override
            public int compare(card o1, card o2) {

                return o1.getSize() - o2.getSize();
            }
        });

返回值的作用：

1.若为负，sort方法的内部算法会自动将o1排在前面

2.若为正，sort方法的内部算法会自动将o1排在后面

3.若为零，sort方法的内部算法会使两者在集合中的相对位置保持不变

下述是发牌看牌的完整代码

public class main {
    public static void main(String[] args) {
        room room = new room();

//        创建两个农民以及一个地主 这里令Rain为地主
        List<card> John = new ArrayList<>();
        List<card> Jack = new ArrayList<>();
        List<card> Rain = new ArrayList<>();
//        给玩家发牌 注意这里只发了51张牌 还有三张牌要另发给地主

//        增强for循环极其类似于c语言中的指针遍历数组，不利用索引进行集合的遍历
        for (int i = 0 ; i < room.getCards().size() - 3 ;++i) {
//            算法思路：模三为0 给JOhn 模三为1给Jack 模三为2给Rain
            if(i % 3 == 0){
                John.add(room.getCards().get(i));
            }
            if(i % 3 == 1){
                Jack.add(room.getCards().get(i));
            }
            if(i % 3 == 2){
                Rain.add(room.getCards().get(i));
            }
        }
//        在Java中，如果你直接打印一个列表对象，它会调用列表的toString()方法来打印出列表的内容。
//        因为list对象的tostring方法自动重写了

//        将剩下三张牌分给地主
        int cout = 3;
        while(!(cout == 0)){
            int Index = room.getCards().size()  - cout;
            Rain.add(room.getCards().get(Index));
            cout--;
        }
//         看牌
        System.out.println(Rain);

//        将Rain的牌进行排序
        Collections.sort(Rain, new Comparator<card>() {
            @Override
            public int compare(card o1, card o2) {

                return o1.getSize() - o2.getSize();
            }
        });
        System.out.println(John);
    }

}