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

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

本帖最后由 山西_李帅 于 2013-4-1 17:50 编辑

做出一副扑克牌(不包含大小王)?  大家都来试一下。

15 个回复

倒序浏览
怎么个做法啊?
回复 使用道具 举报
邵震 发表于 2013-4-1 13:11
怎么个做法啊?

等下,我在研究,一会给你发上来
回复 使用道具 举报
本帖最后由 山西_李帅 于 2013-4-1 13:14 编辑
邵震 发表于 2013-4-1 13:11
怎么个做法啊?

就是打印出52张扑克牌。     
这个基本你前几天学的都用上了,  检测一下
这也是老师给我们留的作业题。  试下吧
回复 使用道具 举报
/*
        做出一副扑克牌(不包含大小王)
        分析:
        1, 通过一张扑克牌抽象出一个扑克牌类,通过分析,扑克牌类只有两个成员属性,一个是花色color,一个是值number。
        2, 将color 、 number私有化(private),通过set/get方法操作
        3, 为扑克牌类建立连个构造函数
                1,无参构造                通过set/get方法赋值和取值
                2,有参构造                建立对象时直接赋值
        4, 分析扑克牌的花色和值是固定的
                1,花色为:红桃,黑桃,方块,梅花
                2,值为:A,2,3,4,5,6,7,8,9,10,J,Q,K
                                                                ————使用数组去操作
        5, 创建一个Poker类型数组,用于存储扑克(重点)
                int[] arr = new int[5];                        //建一个int类型的数组arr
                同样道理
                Poker[] ps = new Poker[];                //建一个Poker类型的数组 ps
*/
class Test2
{
        public static void main(String[] args){
                String[] cs = {"红桃","黑桃","方块","梅花"};                //建一个花色的数组
                String[] ns = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};                //建一个值的数组
                Poker[] ps = new Poker[cs.length*ns.length];                //建一个Poker类型的数组,他的长度为cs乘以ns
                int index=0;                        //定义ps的下标变量
                for(int i = 0; i<cs.length; i++){
                        for(int j = 0; j<ns.length; j++){
                                //ps[index++] = new Poker("红桃","A");         //将ps[index]初始化,并且自动累加;通过有参构造赋值
                                ps[index++] = new Poker(cs[i],ns[j]);
                        }
                }
               
                //遍历ps数组
                for(int i = 0; i<ps.length; i++){
                        //控制当一种花色打印完换行
                        if(i%ns.length==0){
                                System.out.println();
                        }
                        ps[i].show();
                }

        }

}





/*
        建立一个扑克类。
        两个成员属性 color number
        将两个成员属性私有化,并建立set和get方法
*/
class Poker
{
        private String color;
        private String number;                        //因为值里面有10所以不能用char类型

        //无参构造
        Poker(){}

        //有参构造
        Poker(String color, String number){
                this.color=color;
                this.number=number;
        }
       
        //color的set方法
        public void setColor(String color){
                this.color=color;
        }

        //number的set方法
        public void setNumber(String number){
                this.number=number;
        }
       
        //color的get方法
        public String getColor(){
                return color;
        }

        //number的get方法
        public String getNumber(){
                return number;
        }

        //显示一张扑克牌show方法
        public void show(){
                System.out.print(color+number+"  ");
        }



}

评分

参与人数 1技术分 +1 收起 理由
张熙韬 + 1 神马都是浮云

查看全部评分

回复 使用道具 举报
邵震 发表于 2013-4-1 13:11
怎么个做法啊?

做出来了, 代码比较垃圾,将就看吧
回复 使用道具 举报
我是用面向对象的方式实现的,分享下。。
  1. package Test;

  2. import java.util.ArrayList;
  3. import java.util.Collections;
  4. import java.util.List;
  5. /*
  6. 分析:
  7.         1、一副扑克牌用Poker表示
  8.         2、每一张牌用Card表示
  9. */

  10. //表示一副扑克牌
  11. public class Poker{
  12.         //定义常量
  13.         public final static String[] VALUES = {
  14.                 "A","2","3","4","5","6","7","8","9","10","J","Q","K"
  15.         };
  16.         public final static String[] COLORS = {"红桃","黑桃","方块","梅花"};
  17.         //一个Poker对象包含52个Card对象
  18.         private List<Card> cards = new ArrayList<Card>();
  19.         //构造方法:初始化出所有Card
  20.         public Poker(){
  21.                 for(String value : VALUES){
  22.                         for(String color : COLORS){
  23.                                 cards.add(new Card(value,color));
  24.                         }
  25.                 }
  26.         }
  27.         //获得每一张牌
  28.         public List<Card> getCards(){
  29.                 return this.cards;
  30.         }
  31.         //洗牌
  32.         public List<Card> shuffle(){
  33.                 Collections.shuffle(cards);
  34.                 return cards;
  35.         }
  36.         //程序入口
  37.         public static void main(String[] args) {
  38.                 Poker p = new Poker();
  39.                 List<Card> cards = p.getCards();
  40.                 //cards = p.shuffle();
  41.                 for(Card c : cards){
  42.                         System.out.println(c.getColor()+"--"+c.getValue());
  43.                 }
  44.         }
  45. }
  46. //表示一张扑克牌
  47. class Card {
  48.         private String value;
  49.         private String color;
  50.         public Card(String value, String color) {
  51.                 super();
  52.                 this.value = value;                //每张牌一初始化就有值和颜色,且不可改变,只有get方法
  53.                 this.color = color;
  54.         }
  55.         public String getValue() {
  56.                 return value;
  57.         }
  58.         public String getColor() {
  59.                 return color;
  60.         }       
  61. }
复制代码

评分

参与人数 2技术分 +1 黑马币 +15 收起 理由
张熙韬 + 1
山西_李帅 + 15 很给力!

查看全部评分

回复 使用道具 举报
王亚东 发表于 2013-4-1 15:44
我是用面向对象的方式实现的,分享下。。

:funk:   还是你厉害, 有的都看不懂, <>这尖括号是什么?    那你能给我说下乱序的思想吗?就是相当于洗牌了。   让它乱序一下
回复 使用道具 举报
山西_李帅 发表于 2013-4-1 16:26
还是你厉害, 有的都看不懂, 这尖括号是什么?    那你能给我说下乱序的思想吗?就是相当于洗 ...

<>这是泛型,你还没学到把,加了泛型集合中的对象在取出来的时候就不用转型了,直接使用
说实话,乱序我没想过,见到Collections工具类有个shuffle方法,可以对一个list集合洗牌,直接使用。
回复 使用道具 举报
山西_李帅 发表于 2013-4-1 16:26
还是你厉害, 有的都看不懂, 这尖括号是什么?    那你能给我说下乱序的思想吗?就是相当于洗 ...

我试了下,这样可以:
  1. public class Demo01 {
  2.         public static void main(String[] args) {
  3.                 String[] strs = new String[]{"aaa","bbb","ccc","ddd","eee"};
  4.                 Random r =  new Random();
  5.                 for(int i = strs.length;i>1;i--){
  6.                         String temp = strs[i-1];        //从数组最后一个元素往前取
  7.                         int j = r.nextInt(i);                //随机出数组中小于当前元素的下标
  8.                         strs[i-1] = strs[j];                //交换
  9.                         strs[j] = temp;
  10.                 }
  11.                 for(String s : strs){
  12.                         System.out.println(s);                //每次打印的结果都不一样
  13.                 }
  14.         }
  15. }
复制代码
回复 使用道具 举报
本帖最后由 HM周一帆 于 2013-4-1 17:33 编辑

               
import java.util.Random;

    class Cards
         {
             public static void main(String[] args)
                 {

                String[] cs={"红桃","黑桃","方块","梅花"};
                //值
                String[] ns={"A" ,"2" ,"3","4" ,"5", "6", "7", "8", "9", "10", "J", "Q", "K"};
                //描述扑克盒
                Poker[] ps=new Poker[cs.length*ns.length];
               
                int index=0;//用来控制ps数组中的每一张扑克牌的下标。
                for(int i=0;i<cs.length;i++){//控制花色
                        
                        for(int j=0;j<ns.length;j++){//控制值
                                
                                //ps[index]=new Poker(cs,ns[j]);
                                ps[index]=new Poker();
                                ps[index].setColor(cs);
                                ps[index].setNumber(ns[j]);
                                index++;
                        }
                }
                Random r = new Random();
                for(int i=0;i<52;i++)
                {
                        int j = r.nextInt(52);
                      Poker temp = ps[j];
                        ps[j]=ps;
                       ps=temp;              
            }
                       for(int i=0;i<ps.length;i++){
                        if(i%ns.length==0){
                                System.out.println();
                        }
                        ps.show();
                }

               
                }
               
        }



class Poker
{
        private String color;//花色
        private String number;//值
        //无参构造
        Poker(){
        }
        //有参构造  参数代表的是扑克的花色与值
        Poker(String color,String number){
                //在构造方法中使用this  因为Poker构造方法中的局部变量color,number与类中的成员变量重名。

                this.color=color;
                this.number=number;
        }
        //color属性的set方法
        public void setColor(String color){
                this.color=color;
        }
        //number属性的set方法
        public void setNumber(String number){
                this.number=number;
        }
        //color属性的get方法
        public String getColor(){
                return color;
        }
        //number属性的get方法
        public String getNumber(){
                return number;
        }


        //用来显示扑克内容

        void show(){
               
                System.out.print(color+number+" ");
        }
  
}
我这个实现了洗牌的功能,你可以看看

评分

参与人数 2技术分 +1 黑马币 +24 收起 理由
张熙韬 + 1
山西_李帅 + 24 赞一个!

查看全部评分

回复 使用道具 举报
HM周一帆 发表于 2013-4-1 17:29
import java.util.Random;

    class Cards

擦, 我觉得你和我是一个班的。
回复 使用道具 举报
山西_李帅 发表于 2013-4-1 17:30
擦, 我觉得你和我是一个班的。

:handshake
回复 使用道具 举报
                           Random r = new Random();
                for(int i=0;i<52;i++)
                {
                        int j = r.nextInt(52);
                        Poker temp = ps[j];
                        ps[j]=ps[i];
                        ps[i]=temp;
                       }
这个主要是实现 洗牌的方法               
回复 使用道具 举报
HM周一帆 发表于 2013-4-1 17:29
import java.util.Random;

    class Cards

谢谢啊,  搞出来了。  

但是你代码好像错了。

就是随机数那里。

//洗牌也就是打乱ps数组排序
                Random ran = new Random();
                        for(int i=0;i<52;i++){
                                int j = ran.nextInt(52);
                                Poker temp = ps[j];
                                ps[j]=ps;
                                ps=temp;
            }

应该是这样吧。 还是谢谢你啊
回复 使用道具 举报
  1. package exercises;
  2. /*做出一副扑克牌(不包含大小王)?*/
  3. public class Cards {
  4.         public static void main(String[] args){
  5.                 CardNum[] num=CardNum.values();
  6.                 CardType[] type=CardType.values();
  7.                 for(CardNum n:num){
  8.                         for(CardType t:type){
  9.                                 //不用复写toString同样可以实现,但不怎么好看.不用toString代码就很少了.但用了,更形象一点吧
  10.                                 System.out.print(n+" "+t+" ");
  11.                         }
  12.                         System.out.println();
  13.                 }
  14.         }
  15. }
  16. enum CardNum{
  17.         NUM1(CardType.HEITAO),NUM2(CardType.HEITAO),NUM3(CardType.HEITAO),NUM4(CardType.HEITAO),
  18.         NUM5(CardType.HEITAO),NUM6(CardType.HEITAO),NUM7(CardType.HEITAO),NUM8(CardType.HEITAO),
  19.         NUM9(CardType.HEITAO),NUMJ(CardType.HEITAO),NUMQ(CardType.HEITAO),NUMK(CardType.HEITAO);
  20.         private CardType type;
  21.         CardNum(CardType type){
  22.                 this.type=type;
  23.         }
  24.         /*public String toString(){//可以不用写这个方法,导致代码过多.而且不实用
  25.                 switch(this){
  26.                         case NUM1:
  27.                                 return "1";
  28.                         case NUM2:
  29.                                 return "2";
  30.                         case NUM3:
  31.                                 return "3";
  32.                         case NUM4:
  33.                                 return "4";
  34.                         case NUM5:
  35.                                 return "5";
  36.                         case NUM6:
  37.                                 return "6";
  38.                         case NUM7:
  39.                                 return "7";
  40.                         case NUM8:
  41.                                 return "8";
  42.                         case NUM9:
  43.                                 return "9";
  44.                         case NUMJ:
  45.                                 return "J";
  46.                         case NUMQ:
  47.                                 return "Q";
  48.                         case NUMK:
  49.                                 return "K";
  50.                 }
  51.                 return null;
  52.         }*/
  53. }
  54. enum CardType{
  55.         HEITAO,HONGTAO,HEIXING,HONGXING;
  56.         /*public String toString(){
  57.                 switch(this){
  58.                         case HEITAO:
  59.                                 return "#";//用这种符号代替几种不同类型的棋牌.
  60.                         case HONGTAO:
  61.                                 return "%";
  62.                         case HEIXING:
  63.                                 return "^";
  64.                         case HONGXING:
  65.                                 return "&";
  66.                 }
  67.                 return null;
  68.         }*/
  69. }
复制代码
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马