1. <p>/*
   
2. 需求： 实现扑克牌的洗牌 发牌 效果
   
3. 
   
4. 首先定义一个扑克牌的类，定义了扑克牌的花色，点数，能容纳不定牌数的数组，以及查看扑克牌的方法
   
5. 
   
6. 然后定义一个牌组类，继承于扑克牌类，用单例设计模式，内存中只能有1副牌，并且初始化为52张4花色13点数的牌组
   
7. 这个类有洗牌和发牌的方法
   
8. 
   
9. 最后定义一个手牌类，继承于扑克牌类，牌组类对象发牌的时候该类被创建，并得到所发的牌，该类还应该有一个理牌的方法
   
10. 
    
11. */
    
12. 
    
13. import java.util.*;
    
14. 
    
15. class Card  
    
16. {
    
17.         private String[] point = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
    
18.         private String[] suit = {"黑桃","红桃","梅花","方片"};
    
19.         int[][] cards; //一维数组中，第一个为花色，第二个为点数，第三个为位置标示符
    
20.         public void show()
    
21.         {
    
22.                 for (int i=0;i<cards.length ;i++ )
    
23.                 {
    
24.                         System.out.println(suit[cards[i][0]]+"_"+point[cards[i][1]]+"_"+cards[i][2]);
    
25.                 }
    
26.         }
    
27. }
    
28. 
    
29. class Deck extends Card     
    
30. {
    
31.         private static int x=52;
    
32.         private Deck()
    
33.         {
    
34.                 super.cards = new int[x][3];
    
35.                 for (int i=0 ; i<4 ;i++ )
    
36.                 {
    
37.                         for (int j=0; j<13 ; j++)
    
38.                         {
    
39.                                 super.cards[j+i*13][0] = i;
    
40.                                 super.cards[j+i*13][1] = j;
    
41.                                 super.cards[j+i*13][2] = j+i*13;
    
42.                         }
    
43.                 }
    
44.         }
    
45.         private static Deck d = new Deck();
    
46. 
    
47.         public static Deck getDeck() //单例设计模式，内存中只能有一副牌
    
48.         {
    
49.                 return d;
    
50.         }
    
51.         public int getNum()  //可以得到牌组剩余的张数
    
52.         {
    
53.                 return x;
    
54.         }
    
55.         public void shuffle()  //洗牌
    
56.         {
    
57.                 x=52;
    
58.                 Random ran = new Random();
    
59.                 for (int i=0;i<x ;i++ )
    
60.                 {
    
61.                         cards[i][2] = ran.nextInt() % super.cards.length; //产生一个随机数，并把它赋给扑克牌的位置标识符
    
62.                 }
    
63.                 sort();  //根据位置标识符从小到大排列牌组
    
64.         }
    
65. 
    
66.         public Hands[] deal(int pnum,int cnum)  //返回一个手牌类数组，参数pnum是参与人数，cnum是没人发的牌数
    
67.         {
    
68.                 Hands[] hands;
    
69.                 if (x<pnum*cnum)  //如果牌组中剩余的牌不够发则提示并跳出
    
70.                 {
    
71.                         System.out.println("牌组的牌不够，请重新洗牌");
    
72.                         return null;
    
73.                 }
    
74.                 /*
    
75.                 这里我不知道用什么办法能定义带参数的类的数组，只能想到这样写，不知道大家有什么更好的办法？
    
76.                 */
    
77.                 hands = new Hands[pnum];  //定义手牌类数组
    
78.                 for (int i=0;i<pnum ;i++ )
    
79.                 {
    
80.                         hands[i]=new Hands(cnum);  //初始化这个数组的元素
    
81.                 }
    
82.                 for (int i=0; i<cnum ; i++ )
    
83.                 {
    
84.                         for (int j=0;j<pnum ;j++)
    
85.                         {
    
86.                                 hands[j].cards[i][0]=super.cards[x-(i*cnum+j)-1][0]; //牌从数组的最后开始发，这样下标，0到(x-pnum*cnum)，就是剩余的牌
    
87.                                 hands[j].cards[i][1]=super.cards[x-(i*cnum+j)-1][1];
    
88.                                 hands[j].cards[i][2]=super.cards[x-(i*cnum+j)-1][2];
    
89.                         }
    
90.                 }
    
91.                 x=x-pnum*cnum;
    
92.                 return hands;
    
93.         }
    
94. 
    
95.         private void sort()  //根据位置标识符，重新排序牌组
    
96.         {
    
97.                 for (int i=0;i<x-1 ;i++ )
    
98.                 {
    
99.                         int n=i;
    
100.                         for (int j=i+1;j<x ;j++ )
     
101.                         {
     
102.                                 if (super.cards[n][2]>super.cards[j][2])
     
103.                                 {
     
104.                                         n = j;
     
105.                                 }
     
106.                         }
     
107.                         if (n!=i)
     
108.                         {
     
109.                                 int[] temp = super.cards[i];
     
110.                                 super.cards[i] = super.cards[n];
     
111.                                 super.cards[n] = temp;
     
112.                         }
     
113.                 }
     
114.         }
     
115. }
     
116. 
     
117. class Hands extends Card
     
118. {
     
119.         int x;
     
120.         Hands(int n)
     
121.         {
     
122.                 x=n;
     
123.                 super.cards = new int[n][3];
     
124.         }
     
125.         public void tidy()
     
126.         {
     
127.                 for (int i=0;i<x-1 ;i++ )
     
128.                 {
     
129.                         int n=i;
     
130.                         for (int j=i+1;j<x ;j++ )
     
131.                         {
     
132.                                 if (super.cards[n][1]>super.cards[j][1])//根据牌的点数大小排序
     
133.                                 {
     
134.                                         n = j;
     
135.                                 }
     
136.                         }
     
137.                         if (n!=i)
     
138.                         {
     
139.                                 int[] temp = super.cards[i];
     
140.                                 super.cards[i] = super.cards[n];
     
141.                                 super.cards[n] = temp;
     
142.                         }
     
143.                 }
     
144.         }
     
145. }
     
146. class  Demo
     
147. {
     
148.         public static void main(String[] args) //测试方法可以无视
     
149.         {
     
150.                 Deck d = Deck.getDeck();
     
151.                 d.shuffle();
     
152.                 d.show();
     
153.                 Hands[] h = d.deal(5,6);
     
154.                 for (int i=0;i<5 ;i++ )
     
155.                 {
     
156.                         System.out.println("---------------------------------------------------------------------------------------------");
     
157.                         h[i].show();
     
158.                         h[i].tidy();
     
159.                         System.out.println("---------------------------------------------------------------------------------------------");
     
160.                         h[i].show();
     
161.                 }
     
162.                 d.deal(5,6);
     
163.                 System.out.println(d.getNum());
     
164.         }
     
165. }
     
166. </p>

复制代码

在论坛上看到的这个题，用自己的方法写的。
浪费了一个晚上的脑细胞，感觉对面向对象的思想理解还不到位，中间反复修改了好几次，无法很好的将事物的描述转成代码
希望大家对以上的代码给点建议
这个注释大家将就着看

1. <p>/*
   
2. 需求： 实现扑克牌的洗牌 发牌 效果
   
3. 
   
4. 首先定义一个扑克牌的类，定义了扑克牌的花色，点数，能容纳不定牌数的数组，以及查看扑克牌的方法
   
5. 
   
6. 然后定义一个牌组类，继承于扑克牌类，用单例设计模式，内存中只能有1副牌，并且初始化为52张4花色13点数的牌组
   
7. 这个类有洗牌和发牌的方法
   
8. 
   
9. 最后定义一个手牌类，继承于扑克牌类，牌组类对象发牌的时候该类被创建，并得到所发的牌，该类还应该有一个理牌的方法
   
10. 
    
11. */
    
12. 
    
13. import java.util.*;
    
14. 
    
15. class Card  
    
16. {
    
17.         private String[] point = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
    
18.         private String[] suit = {"黑桃","红桃","梅花","方片"};
    
19.         int[][] cards; //一维数组中，第一个为花色，第二个为点数，第三个为位置标示符
    
20.         public void show()
    
21.         {
    
22.                 for (int i=0;i<cards.length ;i++ )
    
23.                 {
    
24.                         System.out.println(suit[cards[i][0]]+"_"+point[cards[i][1]]+"_"+cards[i][2]);
    
25.                 }
    
26.         }
    
27. }
    
28. 
    
29. class Deck extends Card     
    
30. {
    
31.         private static int x=52;
    
32.         private Deck()
    
33.         {
    
34.                 super.cards = new int[x][3];
    
35.                 for (int i=0 ; i<4 ;i++ )
    
36.                 {
    
37.                         for (int j=0; j<13 ; j++)
    
38.                         {
    
39.                                 super.cards[j+i*13][0] = i;
    
40.                                 super.cards[j+i*13][1] = j;
    
41.                                 super.cards[j+i*13][2] = j+i*13;
    
42.                         }
    
43.                 }
    
44.         }
    
45.         private static Deck d = new Deck();
    
46. 
    
47.         public static Deck getDeck() //单例设计模式，内存中只能有一副牌
    
48.         {
    
49.                 return d;
    
50.         }
    
51.         public int getNum()  //可以得到牌组剩余的张数
    
52.         {
    
53.                 return x;
    
54.         }
    
55.         public void shuffle()  //洗牌
    
56.         {
    
57.                 x=52;
    
58.                 Random ran = new Random();
    
59.                 for (int i=0;i<x ;i++ )
    
60.                 {
    
61.                         cards[i][2] = ran.nextInt() % super.cards.length; //产生一个随机数，并把它赋给扑克牌的位置标识符
    
62.                 }
    
63.                 sort();  //根据位置标识符从小到大排列牌组
    
64.         }
    
65. 
    
66.         public Hands[] deal(int pnum,int cnum)  //返回一个手牌类数组，参数pnum是参与人数，cnum是没人发的牌数
    
67.         {
    
68.                 Hands[] hands;
    
69.                 if (x<pnum*cnum)  //如果牌组中剩余的牌不够发则提示并跳出
    
70.                 {
    
71.                         System.out.println("牌组的牌不够，请重新洗牌");
    
72.                         return null;
    
73.                 }
    
74.                 /*
    
75.                 这里我不知道用什么办法能定义带参数的类的数组，只能想到这样写，不知道大家有什么更好的办法？
    
76.                 */
    
77.                 hands = new Hands[pnum];  //定义手牌类数组
    
78.                 for (int i=0;i<pnum ;i++ )
    
79.                 {
    
80.                         hands[i]=new Hands(cnum);  //初始化这个数组的元素
    
81.                 }
    
82.                 for (int i=0; i<cnum ; i++ )
    
83.                 {
    
84.                         for (int j=0;j<pnum ;j++)
    
85.                         {
    
86.                                 hands[j].cards[i][0]=super.cards[x-(i*cnum+j)-1][0]; //牌从数组的最后开始发，这样下标，0到(x-pnum*cnum)，就是剩余的牌
    
87.                                 hands[j].cards[i][1]=super.cards[x-(i*cnum+j)-1][1];
    
88.                                 hands[j].cards[i][2]=super.cards[x-(i*cnum+j)-1][2];
    
89.                         }
    
90.                 }
    
91.                 x=x-pnum*cnum;
    
92.                 return hands;
    
93.         }
    
94. 
    
95.         private void sort()  //根据位置标识符，重新排序牌组
    
96.         {
    
97.                 for (int i=0;i<x-1 ;i++ )
    
98.                 {
    
99.                         int n=i;
    
100.                         for (int j=i+1;j<x ;j++ )
     
101.                         {
     
102.                                 if (super.cards[n][2]>super.cards[j][2])
     
103.                                 {
     
104.                                         n = j;
     
105.                                 }
     
106.                         }
     
107.                         if (n!=i)
     
108.                         {
     
109.                                 int[] temp = super.cards[i];
     
110.                                 super.cards[i] = super.cards[n];
     
111.                                 super.cards[n] = temp;
     
112.                         }
     
113.                 }
     
114.         }
     
115. }
     
116. 
     
117. class Hands extends Card
     
118. {
     
119.         int x;
     
120.         Hands(int n)
     
121.         {
     
122.                 x=n;
     
123.                 super.cards = new int[n][3];
     
124.         }
     
125.         public void tidy()
     
126.         {
     
127.                 for (int i=0;i<x-1 ;i++ )
     
128.                 {
     
129.                         int n=i;
     
130.                         for (int j=i+1;j<x ;j++ )
     
131.                         {
     
132.                                 if (super.cards[n][1]>super.cards[j][1])//根据牌的点数大小排序
     
133.                                 {
     
134.                                         n = j;
     
135.                                 }
     
136.                         }
     
137.                         if (n!=i)
     
138.                         {
     
139.                                 int[] temp = super.cards[i];
     
140.                                 super.cards[i] = super.cards[n];
     
141.                                 super.cards[n] = temp;
     
142.                         }
     
143.                 }
     
144.         }
     
145. }
     
146. class  Demo
     
147. {
     
148.         public static void main(String[] args) //测试方法可以无视
     
149.         {
     
150.                 Deck d = Deck.getDeck();
     
151.                 d.shuffle();
     
152.                 d.show();
     
153.                 Hands[] h = d.deal(5,6);
     
154.                 for (int i=0;i<5 ;i++ )
     
155.                 {
     
156.                         System.out.println("---------------------------------------------------------------------------------------------");
     
157.                         h[i].show();
     
158.                         h[i].tidy();
     
159.                         System.out.println("---------------------------------------------------------------------------------------------");
     
160.                         h[i].show();
     
161.                 }
     
162.                 d.deal(5,6);
     
163.                 System.out.println(d.getNum());
     
164.         }
     
165. }
     
166. </p>

复制代码

在论坛上看到的这个题，用自己的方法写的。
浪费了一个晚上的脑细胞，感觉对面向对象的思想理解还不到位，中间反复修改了好几次，无法很好的将事物的描述转成代码
希望大家对以上的代码给点建议
这个注释大家将就着看