JAVA 实现发牌的 改进

　　java是一门面向对象的语言，我们在解决这个问题的时候先找对象。我认为面想对象 “就是把复杂的问题变简单，简单的问题程序化” 。如果我们  创建一盒牌--->洗牌--->选地主牌--->发牌--->发到地主牌--->底牌。这样分析的话这不就成了面向过程吗? 但是若是我们这样实现了今后的还有什么拓展性可言呢?  所以我们要面向对象。这才是java的精髓。

　　下面我们就以面向对象的思想去分析这个问题：发牌的对象有：牌，扑克，玩家，发牌的人。最好的方法是我们先创建这几个类，然后再去定义属性和行为，但是时间关系我就直接把做好的发出来，一个对象一个对象的分析最后再来总结。

　　下面我们先创建牌（Card）类它的主要属性就是牌的名字（name），和每一张牌对应的大小(order)代码如下：

package com.miss.time1227.poker;

/**
 * @author MISS
 *    功能：牌类
 */
public class Card  implements Comparable<Card>{

    /**
     * 牌的名字
     */
    private String name;
    /**
     * 牌的大小
     */
    private int order;

    public Card(String name, int order) {
        this.name = name;
        this.order = order;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getOrder() {
        return order;
    }
    public void setOrder(int order) {
        this.order = order;
    }
    public Card() {

    }
    @Override
    public int compareTo(Card o) {
        // TODO Auto-generated method stub
        if(this.order > o.order){
            return 1;
        }
        if(this.order < o.order){
            return -1;
        }
        return 0;
    }

}

　　在牌这个类中我实现了Comparable这个接口，我将在发牌这个类讲到。

　　那么我们下一步就是创建扑克这个类，它的主要属性就是一盒牌 但是我们得在这个类中创建好代码如下：　

/**
 *
 */
package com.miss.time1227.poker;

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

/**
 * @author MISS
 *    描述：扑克类
 */
public class PuKe{

    /**
     * 牌的集合 card 的泛型
     */
    private List<Card> list = new ArrayList<Card>();

    public PuKe() {

        String[] str = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        int order = 1;

        for (int j = 0; j < str.length; j++) {
            this.list.add(new Card("方块" + str[j],order));
            this.list.add(new Card("梅花" + str[j],order));
            this.list.add(new Card("黑桃" + str[j],order));
            this.list.add(new Card("红心" + str[j],order));
            order++;
        }

        this.list.add(new Card("小王",++order));
        this.list.add(new Card("大王",++order));

    }
    public List<Card> getList() {
        return list;
    }
    public void setList(List<Card> list) {
        this.list = list;
    }
}

　　在这里我们就是创建了一个Card类类型的引用类型的泛型，这里我是在构造方法中实现，其实可以给它一个方法去实现这个创建牌的行为，然后再在构造方法中去调用。上面的代码创建方法也是比较简单易懂，我就是创建一一个数组，然后循环给值，最后再创建大小网。order就是牌的大小，在发完牌排序的时候就会用到。

　　我们在发牌之前是不是要有3个玩家和一副牌才能发啊，这样我们就确定了该类的4个属性 有了我们就来看看它有哪些行为，既然我们要发牌，发牌就是我们主要得行为啊

发牌之前我们先洗牌在Collections 类中的 shuffle 方法就是一个打乱 list的一个方法我们直接调用 不就完成了。在生成地主牌，最后再挨个的发牌。

　　　　

package com.miss.time1227.poker;

import java.util.Collections;
import java.util.List;
import java.util.Random;

/**
 * @author MISS
 *    功能:发牌 */
public class PlayCard {

    private Person p1;
    private Person p2;
    private Person p3;
    private PuKe puKe;

    public PlayCard(Person p1, Person p2, Person p3, PuKe puKe) {
        super();
        this.p1 = p1;
        this.p2 = p2;
        this.p3 = p3;
        this.puKe = puKe;
    }

    public Person getP1() {
        return p1;
    }

    public void setP1(Person p1) {
        this.p1 = p1;
    }

    public Person getP2() {
        return p2;
    }

    public void setP2(Person p2) {
        this.p2 = p2;
    }

    public Person getP3() {
        return p3;
    }

    public void setP3(Person p3) {
        this.p3 = p3;
    }

    public PuKe getPuKe() {
        return puKe;
    }

    public void setPuKe(PuKe puKe) {
        this.puKe = puKe;
    }

    public void fapai() {
        List<Card> cards = puKe.getList();
        Collections.shuffle(cards);//洗牌

        Random random = new Random();
        /**
         * 地主牌
         */
        int hostIndex = random.nextInt(54);
        String host=cards.get(hostIndex).getName();//地主牌
        System.out.println("地主牌： "+host);

        List<Card> list1 = cards.subList(0, 17);
        Collections.sort(list1);
        p1.setPerList(list1);

        List<Card> list2 = cards.subList(17, 34);
        Collections.sort(list2);
        p2.setPerList(list2);

        List<Card> list3 = cards.subList(34, 51);
        Collections.sort(list3);
        p3.setPerList(list3);

        List<Card>  dipai=cards.subList(51, 54);

        String name = "";
        if(display(p1,host)){
            name = p1.getName();
        }
        if(display(p2,host)){
            name = p2.getName();
        }
        if(display(p3,host)){
            name = p3.getName();
        }
        System.out.println("底牌：  ");
        for(Card card:dipai){
            System.out.print(card.getName()+"\t");
        }
        System.out.print(" 地主是： " + name);
        System.out.println();

    }

    public  boolean display(Person p,String host) {
        // TODO Auto-generated method stub

        boolean hostName = false;
        System.out.println(p.getName() + ": ");

        for(Card c : p.getPerList()){
            if(c.getName() == host){
                hostName = true;
                System.out.print(c.getName()+("(地主)")+"\t");
            }else{
                System.out.print(c.getName() +"\t");
            }
        }
        System.out.println();
        return hostName;
    }
}

　　最后我写了个测试类：

　　

/**
 *
 */
package com.miss.time1227.poker;

/**
 * @author Administrator
 *
 */
public class Test {

    public Test() {
        // TODO Auto-generated constructor stub
    }
    public static void main(String[] args) {

        Person p1= new Person();
        p1.setName("小马");
        Person p2= new Person();
        p2.setName("小二");
        Person p3= new Person();
        p3.setName("小牛");

        PuKe puKe = new PuKe();

        PlayCard playCard = new PlayCard(p1,p2,p3,puKe);
        playCard.fapai();

    }
}

　　最终的结果是:

　　

　　最后和大家总结一下，实现地主的发牌就我觉得就是体现了java Collecttion类 的重要性 它在很多方面要比数组方便很多。还有很多封装好的方法大家可以用。

　　写得不是很好，大家可以交流的地方希望大家给我留言。