疯狂JAVA讲义---第六章（下）：面向对象二

面向对象这章的最后给我们讲了枚举类，这个又让我想起了用c++的感觉。java中我还从来没用过，看了这书我才知道枚举类的方便。先看个不用枚举类实现枚举的例子，eg

1. public class Season
2. {
3.     //把Season类定义成不可变的，将其属性也定义成final 
4.     private final String name;
5.     private final String desc;
6.     public static final Season SPRING = new Season("春天" , "趁春踏青");
7.     public static final Season SUMMER = new Season("夏天" , "夏日炎炎");
8.     public static final Season FALL = new Season("秋天" , "秋高气爽");
9.     public static final Season WINTER = new Season("冬天" , "围炉赏雪");
11.     public static Season getSeaon(int seasonNum)
12.     {
13.         switch(seasonNum)
14.         {
15.             case 1 :
16.                 return SPRING;
17.             case 2 :
18.                 return SUMMER;
19.             case 3 :
20.                 return FALL;
21.             case 4 :
22.                 return WINTER;
23.             default :
24.                 return null;
25.         }
26.     }
28.     //将构造器定义成private访问权限 
29.     private Season(String name , String desc)
30.     {
31.         this.name = name;
32.         this.desc = desc;
33.     }
34.     //只为name和desc属性提供getter方法 
35.     public String getName()
36.     {
37.          return this.name;
38.     }
39.     public String getDesc()
40.     {
41.          return this.desc;
42.     }
43. }
44. public class TestSeason
45. {
46.     public TestSeason(Season s)
47.     {
48.         System.out.println(s.getName() + "，这真是一个"+ s.getDesc() + "的季节");
49.     }
50.     public static void main(String[] args) 
51.     {
52.         //直接使用Season的FALL常量代表一个Season对象
53.         new TestSeason(Season.FALL);
54.     }
55. }

 

现在用枚举，eg

2. public class TestEnum
4. {
5.     public void judge(SeasonEnum s)
6.     {
7.         //switch语句里的表达式可以是枚举值
8.         switch (s)
9.         {
10.             case SPRING:
11.                 System.out.println("春暖花开，正好踏青");
12.                 break;
13.             case SUMMER:
14.                 System.out.println("夏日炎炎，适合游泳");
15.                 break;
16.             case FALL:
17.                 System.out.println("秋高气爽，进补及时");
18.                 break;
19.             case WINTER:
20.                 System.out.println("冬日雪飘，围炉赏雪");
21.                 break;
22.         }
23.     }
24.     public static void main(String[] args)
25.     {
26.         //所有枚举类都有一个values方法，返回该枚举类的所有实例
27.         for (SeasonEnum s : SeasonEnum.values())
28.         {
29.             System.out.println(s);
30.         }
31.         new TestEnum().judge(SeasonEnum.SPRING);
32.     }
33. }

方便了不少，最主要是思路清晰了。

然后讲下垃圾回收机制中的花样。本来我觉得垃圾回收是jvm的事情。现在才知道由垃圾回收引出了，强，软，弱，虚四种引用，软引用是当内存不足时回收，弱和虚差不多，相当于类没引用，只是虚引用的回收会被记录下来，可以跟踪对象的回收。

最后收尾讲了jar文件的使用，其实jar，war，ear都是用zip来压缩的，只是里面多点配置文件。命令的使用，我就不说了，这个网上很多。

这里我主要讲下如何打个可执行的包：

在jar包的manifest.mf中加入Main_Class:(空格)包名.类名（回车）

千万注意空格和回车不要忘了

 

本章习题

定义一个类，封装一桌梭哈游戏。

1. public class ShowHand
2. {
3.     //定义该游戏最多支持多少个玩家
4.     private final int PLAY_NUM = 5;
5.     //定义扑克牌的所有花色和数值，
6.     //下面四个是特殊字符，会在控制台打印出方块, 草花 , 红心 , 黑桃
7.     private String[] types = {"/4  " , "/5  " ,"/3  "  , "/6  "};
8.     private String[] values = {"2" , "3" , "4" , "5" , "6" , "7" , "8" , 
9.         "9", "10" , "J" , "Q" , "K" , "A"};
10.     //card是一局游戏中剩下的扑克牌
11.     private List<String> cards = new LinkedList<String>();
12.     //定义所有的玩家
13.     private String[] players = new String[PLAY_NUM];    
14.     //所有玩家手上的扑克牌
15.     private List<String>[] playersCards = new List[PLAY_NUM];
16.     /**
17.      * 初始化扑克牌，放入52张扑克牌，并且使用shuffle方法将它们按随机顺序排列
18.      */
19.     public void initCards()
20.     {
21.         for (int i = 0 ; i < types.length ; i++ )
22.         {
23.             for (int j = 0; j < values.length ; j++ )
24.             {
25.                 cards.add(types[i] + values[j]);
26.             }
27.         }
28.         //随机排列
29.         Collections.shuffle(cards);
30.     }
31.     /**
32.      * 初始化玩家,为每个玩家分派用户名
33.      */
34.     public void initPlayer(String... names)
35.     {
36.         if (names.length > PLAY_NUM || names.length < 2)
37.         {
38.             //校验玩家数量，此处使用异常机制更合理
39.             System.out.println("玩家数量不对");
40.             return ;
41.         }
42.         else
43.         {
44.             //初始化玩家用户名
45.             for (int i = 0; i < names.length ; i++ )
46.             {
47.                 players[i] = names[i];
48.             }
49.         }
50.     }
51.     /**
52.      * 初始化玩家手上的扑克牌，开始游戏时每个玩家手上的扑克牌为空，
53.      * 程序使用一个长度为0的LinkedList来表示。
54.      */
55.     public void initPlayerCards()
56.     {
57.         for (int i = 0; i < players.length ; i++ )
58.         {
59.             if (players[i] != null && !players[i].equals(""))
60.             {
61.                 playersCards[i] = new LinkedList<String>();
62.             }
63.         }
64.     }
65.     /**
66.      * 输出全部扑克牌，该方法没有实际作用，仅用作测试
67.      */
68.     public void showAllCards()
69.     {
70.         for (String card : cards )
71.         {
72.             System.out.println(card);
73.         }
74.     }
76.     /**
77.      * 派扑克牌
78.      * @param first 最先派给谁
79.      */
80.     public void deliverCard(String first)
81.     {
82.         //调用ArrayUtils工具类的search方法，查询出指定元素在数组中的索引
83.         int firstPos = ArrayUitls.search(players , first);
84.         //依次给位于该指定玩家之后的每个玩家派扑克牌
85.         for (int i = firstPos; i < PLAY_NUM ; i ++)
86.         {
87.             if (players[i] != null)
88.             {
89.                 playersCards[i].add(cards.get(0));
90.                 cards.remove(0);
91.             }
92.         }
93.         //依次给位于该指定玩家之前的每个玩家派扑克牌
94.         for (int i = 0; i < firstPos ; i ++)
95.         {
96.             if (players[i] != null)
97.             {
98.                 playersCards[i].add(cards.get(0));
99.                 cards.remove(0);
100.             }
101.         }       
102.     }
103.     /**
104.      * 输出玩家手上的扑克牌
105.      * 实现该方法时，应该控制每个玩家看不到别人的第一张牌，但此处没有增加该功能
106.      */
107.     public void showPlayerCards()
108.     {
109.         for (int i = 0; i < PLAY_NUM ; i++ )
110.         {
111.             //当该玩家不为空时
112.             if (players[i] != null)
113.             {
114.                 //输出玩家
115.                 System.out.print(players[i] + " ： " );
116.                 //遍历输出玩家手上的扑克牌
117.                 for (String card : playersCards[i])
118.                 {
119.                     System.out.print(card + "/t");
120.                 }
121.             }
122.             System.out.print("/n");
123.         }
124.     }
126.     public static void main(String[] args) 
127.     {
128.         ShowHand sh = new ShowHand();
129.         System.out.println(Arrays.toString(sh.types));
130.         sh.initPlayer("电脑玩家" , "孙悟空");
131.         sh.initCards();
132.         sh.initPlayerCards();
133.         //下面测试所有扑克牌，没有实际作用 
134.         sh.showAllCards();
135.         System.out.println("---------------");
136.         //下面从"孙悟空"开始派牌
137.         sh.deliverCard("孙悟空");
138.         sh.showPlayerCards();
139.         /*
140.             这个地方需要增加处理:
141.             1.牌面最大的玩家下注.
142.             2.其他玩家是否跟注?
143.             3.游戏是否只剩一个玩家?如果是，则他胜利了。
144.             4.如果已经是最后一张扑克牌，则需要比较剩下玩家的牌面大小.
145.         */
146.         //再次从"电脑玩家"开始派牌
147.         sh.deliverCard("电脑玩家");
148.         sh.showPlayerCards();
149.     }
150. }