美文网首页
poker比大小的Java实现

poker比大小的Java实现

作者: 黑铁选手 | 来源:发表于2019-08-09 23:14 被阅读0次

    目的

    用Java语言对扑克牌比大小进行实现,同时强化对索引(index)和静态(static)、构造方法、定义类和数组练习。

    相关技术 ,及其使用

    通过定义多个类对这个游戏进行细化和封装 例如:Constant 、GameCenter、 Player、 PlayerManager 、Poker 、PokerManager 、PokerType 、 Utils这几个类,每个类里面都有多种构造方法
    例如:
    PlayerManager类

    public class PokerManager {
        //保存一副牌
       private ArrayList<Poker> pokers = new ArrayList<>();
    
       //创建静态变量 单例对象通过manager访问
        public static final PokerManager manager = new PokerManager();
       //私有化构造方法
        private PokerManager(){
    
        }
        //定义一个方法生成一副牌
        public void deal(){
            //遍历整个点数的数组
            for(int i = 0; i < Constant.DOTS.length;i++){
                //获取对应的点数
                String dot = Constant.DOTS[i];
    
                //生成4种花色
    
                for(int j = 0;j < Constant.TYPES.length; j++){
                    //创建一张牌
                    Poker poker = new Poker(dot,Constant.TYPES[j]);
                    //将这张牌保存起来
                    pokers.add(poker);
                }
    }
            //洗牌
            Collections.shuffle(pokers);
    
        }
        //显示一张牌
        public void show(){
            for(Poker poker:pokers){
                System.out.print(poker.getDot()+poker.getType().getPic()+" ");
            }
            System.out.println();
        }
    
        /**
         * 给每个玩家发牌
         *
         * @param players 所有参与玩家
         */
        public void dealCards(ArrayList<Player> players) {
            for (int i = 0;i < players.size();i++){
                Player player = players.get(i);
    
                //将数组里面对应的扑克牌给对应的玩家
                player.poker = pokers.get(i);
            }
        }
    }
    
    

    test类对ArraList的使用:

    package day4;
    
    import java.sql.Array;
    import java.util.ArrayList;
    
    /**
     * 单例设计模式
     * 1、不允许用户创建这个类的对象
     *   将类的构造方法私有化
     * 2、在自己的类里面提供创建对象的方法
     */
    public class Test {
        public static void main (String [] args){
            //正常情况下创建一个对象
           // Poker p = new Poker();
            Poker.shared.test();
            Player.getInstans();
    
        }
    }
    
    //一、第一种单例设计模式创建方法 饿汉式
    class Poker{
    
        //1、默认构造函数
        //public Poker(){}
        //私有化
        private Poker(){}
        //2、定义一个静态的成员变量 记录这个单例对象
    
        /**
         * 单例命名: default sharedInstance  manager
         */
        public static final Poker shared = new Poker();
    
        public void test(){}
    }
    
    //懒汉式
    class Player{
    
        //1、私有化
        private Player(){}
        //2、创建静态变量
       public static Player shared = null;
        //3、提供给外部一个访问的方法
        public static  Player getInstans(){
            //锁
            Object b =new Object();
            synchronized (b) {
                if (shared == null) {
                    //如果没有创建  那么就创建一个
                    shared = new Player();
    
                }
            }
            return shared;
        }
    }
    
    /**
     * 数组里面保存的都是对象的引用(指针)
     * 改变数组里面的对象的属性变量
     * 原始对象的值也跟着改变
     * 因为大家都是指向同一个内存空间
     */
    class Test2{
        public static void main(String[] args){
            //线性表  <操作对象>泛型 名字 里面必须要指定
            ArrayList<Person> people = new ArrayList<>();
            //size 获取数组的元素
            people.size();
            //添加数据
            Person xw =new Person();
            people.add(xw);
    
            Person zs = new Person();
            people.add(zs);
            // 访问数据
            Person xw2 = people.get(0);
            xw2.name = "小王";
            System.out.println(xw.name);
        }
    }
    class Person{
        public String name;
    }
    

    这是poker类的一个简单定义和使用:

    import java.util.Arrays;
    
    public class Poker {
        private String dot;
        private PokerType type;
    
        public Poker (){};
        //构造方法
        public Poker(String dot,PokerType type){
            this.dot = dot;
            this.type =type;
        }
        //setter/getter方法
        public void setDot(String dot){
            this.dot =dot;
        }
        public String getDot(){
            return dot;
        }
    
        public PokerType getType() {
            return type;
        }
    
        public void setType(PokerType type) {
            this.type = type;
        }
        public boolean bigerThan(Poker poker){
            int mIndex = Arrays.binarySearch(Constant.DOTS,this.dot);
            int oIndex = Arrays.binarySearch(Constant.DOTS,this.dot);
    
            if(mIndex !=oIndex){
                //点数不同 直接比较
                return mIndex > oIndex;
            }else {
                //点数相同 比较花色
                return this.type.getId() > poker.type.getId();
            }
        }
    }
    
    

    感想

    完成一个简单游戏的代码分析起来简单,但是,当你拿到手上时就很难,你需要不断地去完善,去细化程序,有时候还要去不断地封装,是整个程序看起来更加的完美。但是,想要做到完美就必须要不断地调试,不断地修改,一步一步。今天跟着写了这个代码看着简单写着难,虽然是跟着写但是,还是会碰到出现错误,但又不能迅速的找到出错的地方,写程序是真的不能一蹴而就,要慢慢的来,虽然会出错,但是当你找到这个错误并修改过后,你就会感觉很有成就感。

    相关文章

      网友评论

          本文标题:poker比大小的Java实现

          本文链接:https://www.haomeiwen.com/subject/fmbkjctx.html