Java面向第二天

Java面向第二天

第二天就两个程序 但是有点难。

1.彩票双色球

构建球类

    /**
     * 球（双色球摇奖用的数字球）
     * @author libill
     *
     */
    public class Ball {
        private int number;     //球的号码
        private boolean used;   //球是否被使用过

        /**
         * number属性的访问器
         * @return number 球的号码
         */
        public int getNumber() {
            return number;
        }

        /**
         * used属性的访问器
         * @return used true表示球被使用过，false表示球没有被使用过
         */
        public boolean isUsed() {
            return used;
        }

        /**
         * used属性的修改器
         * @param used true表示球被使用过，false表示球没有被使用过
         */
        public void setUsed(boolean used) {
            this.used = used;
        }

        /**
         * 获取字符串形式的球的号码
         * @return 字符串形式的号码
         */
        public String getNumStr() {
            return number < 10 ? "0" + number : "" + number;
        }

        /**
         * 构造器
         * @param number 球的号码
         */
        public Ball(int number) {
            this.number = number;
            this.used = false;
        }
    }

构建选球机器类

import java.util.Arrays;
import java.util.Comparator;

/**
 * 双色球摇号机
 * @author libill
 *
 */
public class LotteryMachine {
    private Ball[] redBalls = new Ball[33]; //装红色球
    private Ball[] blueBalls = new Ball[16]; //装蓝色球

    /**
     * 装入红色球和蓝色球
     */
    public void load() {
        for (int i = 0; i < redBalls.length; ++i) {
            redBalls[i] = new Ball(i + 1);
        }

        for (int j = 0; j < blueBalls.length; ++j) {
            blueBalls[j] = new Ball(j + 1);
        }
    }

    /**
     * 揺蓝色球
     * @return
     */
    public Ball getBlueBall() {
        return blueBalls[(int) (Math.random() * blueBalls.length)];
    }

    public Ball[] getRedBalls() {
        Ball[] balls = new Ball[6];

        for (int i = 0; i < balls.length; ++i) {
            Ball tempBall = null;
            do {
                int randomIndex = (int) (Math.random() * redBalls.length);
                tempBall = redBalls[randomIndex];
            } while (tempBall.isUsed());

            balls[i] = tempBall;
            tempBall.setUsed(true); //表示这颗球已经用过了
        }

        Arrays.sort(balls, new Comparator<Ball>() {

            @Override
            public int compare(Ball arg0, Ball arg1) {
                return arg0.getNumber() - arg1.getNumber();
            }
        });

        return balls;
    }

    /**
     * 生成随机号码
     * @return  随机号码的字符串
     */
    public String generateRandomNumber() {
        load();
        Ball[] rBalls = getRedBalls();
        Ball bBall = getBlueBall();
        String str = "";
        for (Ball x : rBalls) {
            str += x.getNumStr() + " ";
        }
        str += "| ";
        str += bBall.getNumStr();
        return str;
    }
}

机器选出号码

import java.util.Scanner;

public class TestLotteryMachine {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("机选几注：");
        int n = sc.nextInt();
        LotteryMachine lm = new LotteryMachine();
        for (int i = 0; i < n; i++) {
            System.out.println(lm.generateRandomNumber());
        }
        sc.close();
    }
}

2.奥特曼打小怪兽
创建奥特曼类

/**
 * 奥特曼
 * 
 * @author 
 *
 */
public class Ultraman {
    private static final int MAX_MAGIC = 100;
    private String name; // 名字
    private int hp; // 生命值
    private int mp; // 魔法值

    /**
     * 构造器
     * 
     * @param name 名字
     */
    public Ultraman(String name) {
        this.name = name;
        this.hp = 300;
        this.mp = MAX_MAGIC;
    }

    /**
     * 攻击
     * 
     * @param m 小怪兽
     */
    public void attack(Monster m) {
        int injury = (int) (Math.random() * 21 + 10);
        m.setHp(m.getHp() - injury);
    }

    /**
     * 究极必杀技
     * 
     * @param m 小怪兽
     */
    public void hugeAttack(Monster m) {
        m.setHp(m.getHp() - 50);
    }

    /**
     * 魔法攻击
     * 
     * @param ms 小怪兽的数组
     */
    public void magicAttack(Monster[] ms) {
        mp -= 30;
        for (int i = 0; i < ms.length; i++) {
            Monster m = ms[i];
            if (m.isAlive()) {
                m.setHp(m.getHp() - 20);
            }
        }
    }

    public int getHp() {
        return hp;
    }

    public void setHp(int hp) {
        this.hp = hp > 0 ? hp : 0;
    }

    public int getMp() {
        return mp;
    }

    public void setMp(int mp) {
        this.mp = mp < MAX_MAGIC? mp : MAX_MAGIC;
    }

    @Override
    public String toString() {
        return "奥特曼" + name + "的生命值: " + hp;
    }

}

创建小怪兽类

/**
 * 小怪兽
 * @author 
 *
 */
public class Monster {
    private String name;    // 名字
    private int hp;         // 生命值

    /**
     * 构造器
     * @param name 名字
     */
    public Monster(String name) {
        this.name = name;
        this.hp = 150;
    }

    /**
     * 攻击
     * @param u 奥特曼
     */
    public void attack(Ultraman u) {
        int injury = (int) (Math.random() * 11 + 5);
        u.setHp(u.getHp() - injury);
    }

    public int getHp() {
        return hp;
    }

    public void setHp(int hp) {
        this.hp = hp > 0? hp : 0;
    }

    /**
     * 判断死活
     * @return 活着返回true死了返回false
     */
    public boolean isAlive() {
        return hp > 0;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "小怪兽" + name + "的生命值: " + hp;
    }
}

实现奥特曼PK小怪兽

public class Pk {

    /**
     * 判断是否至少有一只小怪兽是活着的
     * @param ms 小怪兽的数组
     * @return 有活着的小怪兽返回true否则返回false
     */
    public static boolean hasAliveMonster(Monster[] ms) {
        for(int i = 0; i < ms.length; i++) {
            if(ms[i].isAlive()) {
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) throws Exception {
        Ultraman u = new Ultraman("肖继潮");
        Monster[] ms = { 
            new Monster("刘阳"),
            new Monster("陈开"),
            new Monster("曾浩"),
            new Monster("冯启利"),
            new Monster("王谦")
        };

        int round = 1;

        do {
            System.out.println("=========第" + round++ + "回合=========");
            Monster m = null;
            do {
                int mIndex = (int) (Math.random() * ms.length);
                m = ms[mIndex];
            } while(!m.isAlive());
            m.attack(u);
            System.out.println(m.getName() + "小怪兽攻击奥特曼");
            System.out.println(u);
            if(u.getHp() > 0) {
                u.setMp(u.getMp() + 5);
                double rate = Math.random();
                if(rate <= 0.8) {
                    System.out.println("奥特曼攻击小怪兽");
                    u.attack(m);
                }
                else if(rate <= 0.9) {
                    System.out.println("奥特曼使用究极必杀技");
                    u.hugeAttack(m);
                }
                else {
                    if(u.getMp() >= 30) {
                        System.out.println("奥特曼使用魔法攻击");
                        u.magicAttack(ms);
                    }
                    else {
                        System.out.println("奥特曼使用魔法失败");
                    }
                }
                for(Monster tempMonster : ms) {
                    System.out.println(tempMonster);
                }
            }
        } while(u.getHp() > 0 && hasAliveMonster(ms));

        if(u.getHp() > 0) {
            System.out.println("奥特曼胜利!!!");
        }
        else {
            System.out.println("小怪兽胜利!!!");
        }
    }
}