JavaLearn # 面向对象案例：猜丁壳

Posted 2021-06-26 LRcoding

1. 案例设计

最终的运行效果：

类的设计：【常量类 和 工具类 在开发中应该必须定义】

游戏的核心业务： 对战一局

• 用户玩家出手
• 电脑玩家出手
• 输出两方的出手
• 裁判判断谁赢谁输
• 根据结果修改赢家的 winCount
• 输出本局结果
• 判断游戏是否结束

2. 搭建案例框架

• com.lwclick.entity ：存放实体类
• com.lwclick.service ：存放业务代码
• com.lwclick.test ： 存放测试类
• com.lwclick.util ： 存放常量类和工具类

3. 开发工具类和常量类

常量类Constants：

public class Constants {
    public static final int STONE = 0; // 石头
    public static final int SCISSORS = 1; // 剪刀
    public static final int CLOTH = 2; // 布

    public static final int WIN_COUNT = 3;  // 判定胜的次数

    public static final String[] NAME = {"石头", "剪刀", "布"};  // 变量对应的索引获得对应的字符值
}

工具类Utils：

public class Utils {

    /**
     * 不允许在外部创建对象
     * 要调用方法只能通过 类名.方法名  （方法声明成静态的）
     */
    private Utils(){
    }

    /**
     * 产生 [0, n] 的随机数（可以用于电脑玩家随机选择石头 剪刀 布）
     * @param n
     * @return
     */
    public static int getRandom(int n) {
        return new Random().nextInt(n + 1);
    }

    /**
     * 产生[n, m]范围的随机整数
     * @param min
     * @param max
     * @return
     */
    public static int getRandom(int min, int max) {
        return (int)(Math.random() * (max - min + 1)) + min;
    }
}

4. 开发玩家类和裁判类

抽象父类Player：

public abstract class Player {
    private String name;
    private int value; // 取值 0  1  2
    private int winCount;

    public Player() {
    }

    /**
     * 此处构造方法只用 name 即可，因为 value 和 winCount 是变化的
     * @param name
     */
    public Player(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public int getWinCount() {
        return winCount;
    }

    public void setWinCount(int winCount) {
        this.winCount = winCount;
    }

    /**
     * 获取玩家的手势对应的数字，赋给 value 并返回
     * @return
     */
    public abstract int getInputValue();
}

电脑玩家类ComputerPlayer：

public class ComputerPlayer extends Player {
    public ComputerPlayer() {
    }

    public ComputerPlayer(String name) {
        super(name);
    }

    @Override
    public int getInputValue() {
        int value = Utils.getRandom(2);
        this.setValue(value);
        return value;
    }
}

用户玩家类UserPlayer：

public class UserPlayer extends Player {

    public UserPlayer() {

    }

    public UserPlayer(String name) {
        super(name);
    }

    @Override
    public int getInputValue() {
        // 从键盘输入要选择的手势
        Scanner sc = new Scanner(System.in);
        System.out.println("请选择你的手势：[0-石头], [1-剪刀], [2-布]");
        int value = 0;
        try {
            value = sc.nextInt();
        } catch (InputMismatchException e) {
            System.out.println("请正确输入");
        }
        super.setValue(value);
        return value;
    }
}

裁判类Judger：

public class Judger {
    /**
     * 根据某一局两个玩家的出手，判断谁赢谁负
     * @param userValue
     * @param computerValue
     * @return
     */
    public int compare(int userValue, int computerValue) {
        if (userValue == computerValue) {
            return 0;
        } else if (userValue == 0) { // 石头
            if (computerValue == 1) { // 剪刀
                return 1;
            } else { // 布
                return -1;
            }
        } else if (userValue == 1) { // 剪刀
            if (computerValue == 2) { // 布
                return 1;
            } else { // 石头
                return -1;
            }
        } else { // 布
            if (computerValue == 0) { // 石头
                return 1;
            } else { // 剪刀
                return -1;
            }
        }
    }
}

5. 开发游戏类并进行测试

游戏类接口GameInterface：

public interface GameInterface {
    /**
     * 初始化游戏
     */
    public void initGame();

    /**
     * 开始游戏
     */
    public void startGame();

    /**
     * 游戏结束
     */
    public void endGame();
}

猜拳游戏类GuessGame：

public class GuessGame implements GameInterface {
    private Player computer;
    private Player people;

    private Judger judger;
    private int count; // 局数

    @Override
    public void initGame() {
        computer = new ComputerPlayer("阿尔法狗");
        people = new UserPlayer("张三");
        judger = new Judger();
        count = 1;
    }

    @Override
    public void startGame() {
        while (true) {
            System.out.println("\\n----------------------第 " + count + " 局-------------------------");
            // 玩家出手
            int value1 = people.getInputValue();
            // 电脑出手
            int value2 = computer.getInputValue();
            // 输出两方出的什么
            System.out.println(people.getName() + "：" + Constants.NAME[value1]
                            + "     " + computer.getName() + "：" + Constants.NAME[value2]);
            // 裁判进行判断
            int res = judger.compare(value1, value2);
            // 根据本局结果，修改玩家的 winCount;
            modifyWinCount(res);
            // 输出本局比赛的结果
            showResult(res);
            // 判断两方获胜的次数是否到了规定的次数，是否结束游戏
            if (people.getWinCount() == Constants.WIN_COUNT
                    || computer.getWinCount() == Constants.WIN_COUNT) {
                break;
            }
            count++;
        }
    }

    /**
     * 输出一次游戏的比赛结果
     * @param res
     */
    private void showResult(int res) {
        switch (res) {
            case 0:
                System.out.println("本局：和局");
                break;
            case 1:
                System.out.println("本局：" + people.getName() + " 胜利！");
                break;
            case 2:
                System.out.println("本局： " + computer.getName() + " 胜利！");
                break;
        }

        // 当前比分
        System.out.println("当前比分：" + people.getName() + " " + people.getWinCount()
                + "：" + computer.getWinCount() + " " + computer.getName());
    }

    /**
     * 修改选手获胜的次数
     * @param res
     */
    private void modifyWinCount(int res) {
        if (res == 1) {
            people.setWinCount(people.getWinCount() + 1);
        } else if (res == -1) {
            computer.setWinCount(computer.getWinCount() + 1);
        }
    }

    @Override
    public void endGame() {
        System.out.println("============================================================");
        System.out.println("最终比分：" + people.getName() + " " + people.getWinCount()
                + "：" + computer.getWinCount() + " " + computer.getName());
        if (people.getWinCount() > computer.getWinCount()) {
            System.out.println(people.getName() + " 获得了最终的胜利！");
        } else {
            System.out.println(computer.getName() + " 获得了最终的胜利！");
        }
    }
}

测试类Test：

public class Test {
    public static void main(String[] args) {
        GameInterface game = new GuessGame();
        game.initGame();
        game.startGame();
        game.endGame();
    }
}