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

最新推荐文章于 2019-09-06 19:11:02 发布

原创最新推荐文章于 2019-09-06 19:11:02 发布 · 3.6k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #游戏 #string #null #types #getter

J2SE 专栏收录该内容

64 篇文章

订阅专栏

本文探讨了Java中枚举类的使用方法及其优势，并通过对比传统实现方式展示了枚举类的便利性。此外，还介绍了一个梭哈游戏的简单实现案例，包括游戏初始化、发牌和展示玩家手牌等功能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

public class Season
{
    //把Season类定义成不可变的，将其属性也定义成final
    private final String name;
    private final String desc;
    public static final Season SPRING = new Season("春天" , "趁春踏青");
    public static final Season SUMMER = new Season("夏天" , "夏日炎炎");
    public static final Season FALL = new Season("秋天" , "秋高气爽");
    public static final Season WINTER = new Season("冬天" , "围炉赏雪");
    public static Season getSeaon(int seasonNum)
    {
        switch(seasonNum)
        {
            case 1 :
                return SPRING;
            case 2 :
                return SUMMER;
            case 3 :
                return FALL;
            case 4 :
                return WINTER;
            default :
                return null;
        }
    }
    //将构造器定义成private访问权限
    private Season(String name , String desc)
    {
        this.name = name;
        this.desc = desc;
    }
    //只为name和desc属性提供getter方法
    public String getName()
    {
         return this.name;
    }
    public String getDesc()
    {
         return this.desc;
    }
}
public class TestSeason
{
    public TestSeason(Season s)
    {
        System.out.println(s.getName() + "，这真是一个"+ s.getDesc() + "的季节");
    }
    public static void main(String[] args)
    {
        //直接使用Season的FALL常量代表一个Season对象
        new TestSeason(Season.FALL);
    }
}

现在用枚举，eg

public class TestEnum
{
    public void judge(SeasonEnum s)
    {
        //switch语句里的表达式可以是枚举值
        switch (s)
        {
            case SPRING:
                System.out.println("春暖花开，正好踏青");
                break;
            case SUMMER:
                System.out.println("夏日炎炎，适合游泳");
                break;
            case FALL:
                System.out.println("秋高气爽，进补及时");
                break;
            case WINTER:
                System.out.println("冬日雪飘，围炉赏雪");
                break;
        }
    }
    public static void main(String[] args)
    {
        //所有枚举类都有一个values方法，返回该枚举类的所有实例
        for (SeasonEnum s : SeasonEnum.values())
        {
            System.out.println(s);
        }
        new TestEnum().judge(SeasonEnum.SPRING);
    }
}

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

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

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

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

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

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

本章习题

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

public class ShowHand
{
    //定义该游戏最多支持多少个玩家
    private final int PLAY_NUM = 5;
    //定义扑克牌的所有花色和数值，
    //下面四个是特殊字符，会在控制台打印出方块, 草花 , 红心 , 黑桃
    private String[] types = {"/4  " , "/5  " ,"/3  "  , "/6  "};
    private String[] values = {"2" , "3" , "4" , "5" , "6" , "7" , "8" ,
        "9", "10" , "J" , "Q" , "K" , "A"};
    //card是一局游戏中剩下的扑克牌
    private List<String> cards = new LinkedList<String>();
    //定义所有的玩家
    private String[] players = new String[PLAY_NUM];
    //所有玩家手上的扑克牌
    private List<String>[] playersCards = new List[PLAY_NUM];
    /**
     * 初始化扑克牌，放入52张扑克牌，并且使用shuffle方法将它们按随机顺序排列
     */
    public void initCards()
    {
        for (int i = 0 ; i < types.length ; i++ )
        {
            for (int j = 0; j < values.length ; j++ )
            {
                cards.add(types[i] + values[j]);
            }
        }
        //随机排列
        Collections.shuffle(cards);
    }
    /**
     * 初始化玩家,为每个玩家分派用户名
     */
    public void initPlayer(String... names)
    {
        if (names.length > PLAY_NUM || names.length < 2)
        {
            //校验玩家数量，此处使用异常机制更合理
            System.out.println("玩家数量不对");
            return ;
        }
        else
        {
            //初始化玩家用户名
            for (int i = 0; i < names.length ; i++ )
            {
                players[i] = names[i];
            }
        }
    }
    /**
     * 初始化玩家手上的扑克牌，开始游戏时每个玩家手上的扑克牌为空，
     * 程序使用一个长度为0的LinkedList来表示。
     */
    public void initPlayerCards()
    {
        for (int i = 0; i < players.length ; i++ )
        {
            if (players[i] != null && !players[i].equals(""))
            {
                playersCards[i] = new LinkedList<String>();
            }
        }
    }
    /**
     * 输出全部扑克牌，该方法没有实际作用，仅用作测试
     */
    public void showAllCards()
    {
        for (String card : cards )
        {
            System.out.println(card);
        }
    }
    /**
     * 派扑克牌
     * @param first 最先派给谁
     */
    public void deliverCard(String first)
    {
        //调用ArrayUtils工具类的search方法，查询出指定元素在数组中的索引
        int firstPos = ArrayUitls.search(players , first);
        //依次给位于该指定玩家之后的每个玩家派扑克牌
        for (int i = firstPos; i < PLAY_NUM ; i ++)
        {
            if (players[i] != null)
            {
                playersCards[i].add(cards.get(0));
                cards.remove(0);
            }
        }
        //依次给位于该指定玩家之前的每个玩家派扑克牌
        for (int i = 0; i < firstPos ; i ++)
        {
            if (players[i] != null)
            {
                playersCards[i].add(cards.get(0));
                cards.remove(0);
            }
        }
    }
    /**
     * 输出玩家手上的扑克牌
     * 实现该方法时，应该控制每个玩家看不到别人的第一张牌，但此处没有增加该功能
     */
    public void showPlayerCards()
    {
        for (int i = 0; i < PLAY_NUM ; i++ )
        {
            //当该玩家不为空时
            if (players[i] != null)
            {
                //输出玩家
                System.out.print(players[i] + " ： " );
                //遍历输出玩家手上的扑克牌
                for (String card : playersCards[i])
                {
                    System.out.print(card + "/t");
                }
            }
            System.out.print("/n");
        }
    }
    public static void main(String[] args)
    {
        ShowHand sh = new ShowHand();
        System.out.println(Arrays.toString(sh.types));
        sh.initPlayer("电脑玩家" , "孙悟空");
        sh.initCards();
        sh.initPlayerCards();
        //下面测试所有扑克牌，没有实际作用
        sh.showAllCards();
        System.out.println("---------------");
        //下面从"孙悟空"开始派牌
        sh.deliverCard("孙悟空");
        sh.showPlayerCards();
        /*
            这个地方需要增加处理:
            1.牌面最大的玩家下注.
            2.其他玩家是否跟注?
            3.游戏是否只剩一个玩家?如果是，则他胜利了。
            4.如果已经是最后一张扑克牌，则需要比较剩下玩家的牌面大小.
        */
        //再次从"电脑玩家"开始派牌
        sh.deliverCard("电脑玩家");
        sh.showPlayerCards();
    }
}