黑马程序员技术交流社区

标题: 做出一副扑克牌(不包含大小王)？ 大家都来试一下。 [打印本页]
作者: 山西_李帅    时间: 2013-4-1 13:09
标题: 做出一副扑克牌(不包含大小王)？ 大家都来试一下。
本帖最后由 山西_李帅 于 2013-4-1 17:50 编辑

做出一副扑克牌(不包含大小王)？  大家都来试一下。
作者: 邵震    时间: 2013-4-1 13:11
怎么个做法啊？
作者: 山西_李帅    时间: 2013-4-1 13:12
邵震 发表于 2013-4-1 13:11
怎么个做法啊？

等下，我在研究，一会给你发上来
作者: 山西_李帅    时间: 2013-4-1 13:13
本帖最后由 山西_李帅 于 2013-4-1 13:14 编辑
邵震 发表于 2013-4-1 13:11
怎么个做法啊？

就是打印出52张扑克牌。     
这个基本你前几天学的都用上了，  检测一下
这也是老师给我们留的作业题。  试下吧
作者: 山西_李帅    时间: 2013-4-1 14: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+"  ");
        }



}
作者: 山西_李帅    时间: 2013-4-1 14:53
邵震 发表于 2013-4-1 13:11
怎么个做法啊？

做出来了， 代码比较垃圾，将就看吧
作者: 王亚东    时间: 2013-4-1 15:44
我是用面向对象的方式实现的，分享下。。
  1. package Test;

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

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

:funk:   还是你厉害， 有的都看不懂， <>这尖括号是什么？    那你能给我说下乱序的思想吗？就是相当于洗牌了。   让它乱序一下
作者: 王亚东    时间: 2013-4-1 17:14
山西_李帅 发表于 2013-4-1 16:26
还是你厉害， 有的都看不懂， 这尖括号是什么？    那你能给我说下乱序的思想吗？就是相当于洗 ...

<>这是泛型，你还没学到把，加了泛型集合中的对象在取出来的时候就不用转型了，直接使用
说实话，乱序我没想过，见到Collections工具类有个shuffle方法，可以对一个list集合洗牌，直接使用。
作者: 王亚东    时间: 2013-4-1 17:27
山西_李帅 发表于 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:29
本帖最后由 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+" ");
        }
  
}
我这个实现了洗牌的功能，你可以看看
作者: 山西_李帅    时间: 2013-4-1 17:30
HM周一帆 发表于 2013-4-1 17:29
import java.util.Random;

    class Cards

擦， 我觉得你和我是一个班的。
作者: HM周一帆    时间: 2013-4-1 17:31
山西_李帅 发表于 2013-4-1 17:30
擦， 我觉得你和我是一个班的。

:handshake
作者: HM周一帆    时间: 2013-4-1 17:34
                           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;
                       }
这个主要是实现 洗牌的方法               
作者: 山西_李帅    时间: 2013-4-1 17:45
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;
            }

应该是这样吧。 还是谢谢你啊
作者: 陈圳    时间: 2013-4-1 18:43
  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. }
复制代码




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2