A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© hg3093483 中级黑马   /  2013-4-1 16:26  /  1985 人查看  /  3 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 hg3093483 于 2013-4-2 23:26 编辑

请问大神们,怎么封装 扑克类 当中的花色和数字,然后 (打乱顺序打印出来)也就是 洗牌呢?最好能用精简的代码实现以下,非常感谢?我目前还是面向过程中。下面是我的代码。。。
class Test1 {
        public static void main(String[] args) {
                String[] hs = {"红桃","方块","梅花","黑桃"};    //静态初始化扑克的四种花色,用了字符串数组
                String[] zs = {"A","1","2","3","4","5","6","7","8","9","10","J","Q","K"};  //静态初始化扑克十三个数
                String[] hehe = new String[52];                //        创建新数组,代表扑克盒
                for (int x=0;x<hs.length ; x++) {   //  外循环是花色,每一种花色有十三个数字
                        for (int y=0;y<zs.length ;y++ ) {   //内循环是控制十三个数字
                                int z = 0;  // 把int型变量 z 初始化为0,也就是扑克盒数组的0角标
                                hehe[z]= hs[x]+zs[y];   //扑克盒0角标的值是红桃A
                                System.out.print(hehe[z]+" ");  
                                while (z<52) {   // 判断z,当z自增到52时跳出循环
                                        z++;         // z每次自增1
                                }
                                if (y==13) {     // 每当到红桃13时换行
                                        System.out.println();   
                                }
                        }
                }
        }
}

评分

参与人数 1技术分 +1 收起 理由
张熙韬 + 1

查看全部评分

3 个回复

倒序浏览
  1. package exercises;

  2. import java.util.ArrayList;
  3. import java.util.List;
  4. import java.util.Collections;

  5. /*做出一副扑克牌(不包含大小王)?*/
  6. public class Cards {
  7.         public static void main(String[] args){
  8.                 CardNum[] num=CardNum.values();
  9.                 CardType[] type=CardType.values();
  10.                 List<String> list=new ArrayList<String>();
  11.                 for(CardNum n:num){
  12.                         for(CardType t:type){
  13.                                 list.add(n+" "+t);
  14.                         }
  15.                 }
  16.                 Collections.shuffle(list);//Collections内的将集合元素打乱的方法;这里将其作为洗牌操作
  17.                 System.out.println(list);
  18.         }
  19. }
  20. enum CardNum{
  21.         NUM1(CardType.HEITAO),NUM2(CardType.HEITAO),NUM3(CardType.HEITAO),NUM4(CardType.HEITAO),
  22.         NUM5(CardType.HEITAO),NUM6(CardType.HEITAO),NUM7(CardType.HEITAO),NUM8(CardType.HEITAO),
  23.         NUM9(CardType.HEITAO),NUMJ(CardType.HEITAO),NUMQ(CardType.HEITAO),NUMK(CardType.HEITAO);
  24.         private CardType type;
  25.         CardNum(CardType type){
  26.                 this.type=type;
  27.         }
  28.         public String toString(){
  29.                 switch(this){
  30.                         case NUM1:
  31.                                 return "1";
  32.                         case NUM2:
  33.                                 return "2";
  34.                         case NUM3:
  35.                                 return "3";
  36.                         case NUM4:
  37.                                 return "4";
  38.                         case NUM5:
  39.                                 return "5";
  40.                         case NUM6:
  41.                                 return "6";
  42.                         case NUM7:
  43.                                 return "7";
  44.                         case NUM8:
  45.                                 return "8";
  46.                         case NUM9:
  47.                                 return "9";
  48.                         case NUMJ:
  49.                                 return "J";
  50.                         case NUMQ:
  51.                                 return "Q";
  52.                         case NUMK:
  53.                                 return "K";
  54.                 }
  55.                 return null;
  56.         }
  57. }
  58. enum CardType{
  59.         HEITAO,HONGTAO,HEIXING,HONGXING;
  60.         public String toString(){
  61.                 switch(this){
  62.                         case HEITAO:
  63.                                 return "#";//用这种符号代替几种不同类型的棋牌.
  64.                         case HONGTAO:
  65.                                 return "%";
  66.                         case HEIXING:
  67.                                 return "^";
  68.                         case HONGXING:
  69.                                 return "&";
  70.                 }
  71.                 return null;
  72.         }
  73. }
复制代码

评分

参与人数 1技术分 +1 收起 理由
张熙韬 + 1

查看全部评分

回复 使用道具 举报
回复 使用道具 举报
/*
        功能:实现扑克牌的显示以及洗牌的功能
        作者:闫继闯
*/
import java.util.*;
/*
        成员方法
                public static poke[] crePoke();定义一个方法,用来创建扑克牌
                public static void pokeShow(poke[] pArr);显示所有的扑克牌
                public static poke[] randomPokeShow();对数组打乱顺序,洗牌

*/
class  Demo2{
        //入口函数
        public static void main(String[] args) {
                System.out.println("洗牌前");
                pokeShow(crePoke());
                System.out.println("洗牌后");
                pokeShow(randomPokeShow());
        }
        //定义一个方法,用来创建扑克牌
        public static poke[] crePoke() {
                //定义一个存储字符串类型的数组 cArr(colorArray),用来储存扑克牌的四种花色
                String[] cArr = {"红桃","方块","黑桃","梅花"};
                //定义一个存储字符串类型的数组 nArr(numberArray),用来存储扑克牌的13种上边的值
                String[] nArr = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
                /*定义一个存储poke类型的数组,相当于扑克盒,此数组的长度为cArr.length * nArr.length
                  cArr.length是一个数组的方法,计算数组的长度,扑克本身处大小王一个52张,也就是cArr的长度
                  乘以nArr数组的长度,但是由于数组没有初始化,返回值为null
                */
                poke[] pArr = new poke[cArr.length * nArr.length];
                //定义存储扑克牌的下标
                int index = 0;
                //外循环,四种花色的控制
                for (int x = 0;x < cArr.length ;x++ ) {
                        //内循环,13种值
                        for (int y = 0;y < nArr.length;y++ ) {
                                //创建扑克牌,并利用构造函数对其进行初始化,用扑克盒pArr[index],通过index++,
                                //将每张扑克牌存入数组中(扑克盒)
                                pArr[index] = new poke(cArr[x],nArr[y]);
                                //一次下标++,把数据存入数组中
                                index++;
                        }
                }
                return pArr;
        }
        //显示所有的扑克牌
        public static void pokeShow(poke[] pArr) {
        //通过遍历将所有的扑克牌进行显示
                for (int x = 0;x <pArr.length ;x++ ) {
                        //控制,当输出一张花色,进行换行
                        if (x % 13 == 0) {
                                //换行
                                System.out.println();
                        }
                        //调用show()方法进行显示
                        pArr[x].show();       
                }
                //换行
                System.out.println("----------------------------------------------------------------------");
        }
        //对数组打乱顺序,洗牌
        public static poke[] randomPokeShow() {
                //调用方法创建扑克牌,返回poke类型的数组
                poke[] pArr = crePoke();
                //System.out.print(pArr.length);做个小实验返回52
                //创建随机对象
                Random random = new Random();
                //遍历所有数组
                for (int x = 0;x < pArr.length;x++ ) {
                        //任意查找随机值,存入int型p中
                         int p = random.nextInt(pArr.length);
                         //对数组内的值进行调换,以达到乱序洗牌
             poke tmp = pArr[x];
             pArr[x] = pArr[p];
             pArr[p] = tmp;
                }
                //返回数组
                return pArr;
        }
               
}
/*
        定义一个类
        成员属性有:
                String color;
                String number;
        成员方法有:
                public void setColor(String color);
                public void setNumber(String number);
                public String getColor();
                public String getNUmber();
                void show();
        构造方法有:
                public poke();
                public poke(String color,String number);
*/
class poke {
        //创建一个string类型的字符串,color代表扑克牌的花色(红桃,方块,黑桃,梅花);权限为私有,只能在本类中使用
        private String color;
        //创建一个string类型的字符串,number代表扑克牌的是扑克牌上的值,权限为私有,只能在本类中使用
        private String number;
        /*
                定义有参量的构造函数,目的是当创建对象时,对color和number进行初始化
        */
        public poke(String color,String number) {
                this.color = color;
                this.number = number;
        }
        //定义无参数的构造函数
        public poke() {
               
        }
        /*
                创建一个方法,方法名为setColor,返回值为void,参数是string color
                作用是,通过此方法对class类中的成员变量string color 进行赋值
                this代表当前的poke类,public表示此方法为公共方法
        */
        public void setColor(String color) {
                this.color = color;
        }
        /*
                创建一个方法,方法名为setNumber,返回值为void,参数是string number
                作用是,通过此方法通过此方法对class类中的成员变量string number 进行赋值
                this代表当前的poke类,public表示此方法为公共方法
        */
        public void setNumber(String number) {
                this.number = number;
        }
        /*
                public表示此方法为公共方法,返回值为字符串类型,方法名字为getColor,
                作用是,显示成员变量中color.
        */
        public String getColor() {
                return color;
        }
        /*
                public表示此方法为公共方法,返回值为字符串类型,方法名字为getNumber,
                作用是,显示成员变量中color.
        */
        public String getNUmber() {
                return number;
        }
        //将扑克牌的花色和值显示出来,返回值为void
        void show() {
                System.out.print(color+number+" | ");
        }
}

评分

参与人数 1技术分 +1 收起 理由
张熙韬 + 1

查看全部评分

回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马