Java学习第10天

继续面向对象的练习

1. 定义数学里的分数，实现加减乘除功能

• 构建分数类

package org.mobilephone;
 /**
  * 分数（有理数）
  * @author apple
  *
  */
public class Fraction {

    private int num;//分子
    private int den;//分母
    
    /**
     * 构造器：指定分子和分母，创建分数对象
     * @param num 分子
     * @param den 分母
     */
    public Fraction(int num,int den){
        this.num = num;
        this.den = den;
        this.normalize();
        this.simplify();
    } 
    
    /**
     * 构造器:将小数化成分数
     * @param val 一个小数
     */
    public Fraction(double val){
//      int x = (int) (val * 10000);
//      int y = 10000;
//      this.num = x;
//      this.den = y;
        this((int)(val * 10000), 10000);//在构造器里通过this去调用
                                        //已有的构造器（必须写在构造器里的第一句）
    }
    
    /**
     * 分数的加法
     * @param other 另一个分数
     * @return 相加的结果（新的分数）
     */
    public Fraction add(Fraction other){//加法
        return new Fraction(num * other.den + other.num * den, den * other.den);
    }
    
    /**
     * 分数的减法
     * @param other 另一个分数
     * @return 相减的结果（新的分数）
     */
    public Fraction sub(Fraction other){//减法
        return new Fraction(num * other.den - other.num * den, den * other.den);
    }
    
    /**
     * 分数的乘法
     * @param other 另一个分数
     * @return 相乘后的结果（新的分数）
     */
    public Fraction mul(Fraction other){//乘法
        return new Fraction(num * other.num, den * other.den);
    }
    
    /**
     * 分数的除法
     * @param other 另一个分数
     * @return 相除的结果（新的分数）
     */
    public Fraction div(Fraction other){//除法
        return new Fraction(num * other.den, den * other.num);
    }
    
    /**
     * 分数的正规化：让负号在最前面
     */
    public void normalize(){//分数正规化
        if (den < 0) {
            num = -num;
            den = -den;
        }
    }
    
    /**
     * 化简：分子分母同时除以最大公约数
     */
    public void simplify(){//化简
        if (num != 0) {//取绝对值
            int x = Math.abs(num);
            int y = Math.abs(den);
            int factor = gcd(x, y);
            if (factor > 1) {
                num /= factor;
                den /= factor;//分子分母同时除以最大公约数
            }
        }
    }
    
    @Override
    public String toString() {//tostring方法，让输出结果不是哈希码
        if (num == 0) {
            return "0";
        }
        else if (den == 1) {
            return "" + num;
        }
        else{
            return num + "/" + den;
        }
    }
    
    private int gcd(int x,int y){//找最大公约数
        if (x > y) {
            return gcd(y, x);
        }
        else if (y % x != 0) {
            return gcd(y % x,x);
        }
        else {
            return x;
        }
    }
}

• 创建对象，实现分数提供的功能

package org.mobilephone;

public class FractionTest {

    public static void main(String[] args) {
        Fraction f1 = new Fraction(2, 3);
        System.out.println(f1);
        Fraction f2 = new Fraction(3, 4);
        System.out.println(f2);
        System.out.println(f1.add(f2));
        System.out.println(f1.sub(f2));
        System.out.println(f1.mul(f2));
        System.out.println(f1.div(f2));
    }
}

2. 定义扑克类，实现扑克的功能

• 枚举(enum)：定义符号常量最好的方法
• 如果一个变量的值只有有限个选项，通常可以考虑使用枚举类型

1.定义扑克的花色类（枚举法）

package org.mobilephone;
/**
 * 花色
 * @author apple
 *
 */
public enum Suite {
    //黑桃，红心，梅花，方块，鬼牌
    SPADE,HEART,CLUB,DIAMOND,TRUMP
}

2.定义一张扑克牌

package org.mobilephone;

/**
 * 一张牌
 * @author apple
 *
 */
public class Card {
    
    private Suite suite;//花色
    private int face;//点数
    
    /**
     * 构造器
     * @param suite 花色
     * @param face 点数
     */
    public Card(Suite suite, int face) {
        this.suite = suite;
        this.face = face;
    }
    
    @Override
    public String toString() {
        String str = "";
        switch (suite) {
        case SPADE: str = "♠";          
            break;
        case HEART: str = "♥";
            break;
        case CLUB: str = "♣";
            break;
        case DIAMOND: str = "♦";
            break;
        case TRUMP: str = "";
            break;
        }
        switch (face) {
        case 1: str += "A";break;
        case 11: str += "J";break;
        case 12: str += "Q";break;
        case 13: str += "k";break;
        case 15: str += "小王";break;
        case 16: str += "大王";break;
        default: str += face;

        }
        return str;
    }
    
}

3.定义一副扑克牌

package org.mobilephone;
/**
 * 扑克
 * @author apple
 *
 */
public class Poker {

    private Card[] cardsArray = new Card[54];//保存总共多少张牌
    private int currentIndex;//表示发牌发到多少张
    
    /**
     * 构造器:创建一副新牌
     */
    public Poker(){
        Suite[] suites = {Suite.SPADE,Suite.HEART,Suite.CLUB,Suite.DIAMOND};
//      for(int i = 0; i < suites.length; i++){
//          for(int j = 0;j < 13;j++){
//              Card card = new Card(suites[i], j + 1);
//              cardsArray[i * 13 + j] = card;
//          }
//      }
        int[] faces = {1,2,3,4,5,6,7,8,9,10,11,12,13};
        for(int i = 0; i < 52;i++){//初始化
            cardsArray[i] = new Card(suites[i / 13], faces[i % 13]);
        }
        cardsArray[52] = new Card(Suite.TRUMP, 15);
        cardsArray[53] = new Card(Suite.TRUMP, 16);
    }
    
    /**
     * 洗牌:随机乱序
     */
    public void shuffle(){
        for(int i = 0, len = cardsArray.length; i < len; i++){
            int randomIndex = (int) (Math.random() * len);
            Card temp = cardsArray[i];
            cardsArray[i] = cardsArray[randomIndex];
            cardsArray[randomIndex] = temp;
        }
        currentIndex = 0;//洗完牌之后游戏重新开始，相当于重新发牌
    }
    
    /**
     * 发牌
     * @return 一张牌
     */
    public Card deal(){
        return cardsArray[currentIndex++];
    }
    
    /**
     * 判断还有没有牌可以发出
     * @return 还有牌返回true，没有返回false
     */
    public boolean hasMoreCards(){
        return currentIndex < cardsArray.length;
    }
}

4. 定义玩家

package org.mobilephone;

/**
 * 玩家
 * @author apple
 *
 */
public class Player {

    private String name;
    private Card[] cardsOnHand;
    private int totalCards;
    
    /**
     * 构造器
     * @param name 玩家姓名
     */
    public Player(String name) {
        this.name = name;
        cardsOnHand = new Card[3];
    }
    
    /**
     * 摸一张牌
     * @param card 一张牌
     */
    public void getOneCard(Card card){
        if (totalCards < cardsOnHand.length) {
            cardsOnHand[totalCards++] = card;
        }
    }
    
    /**
     * 亮牌
     * @return 玩家手上所有牌的数组
     */
    public Card[] showCards(){
        return cardsOnHand;
    }
    
    /**
     * 获得玩家姓名
     * @return 玩家姓名
     */
    public String getName() {
        return name;
    }
}

5. 扑克牌使用

package org.mobilephone;

public class PokerTest {

    public static void display(Player player){
        System.out.print(player.getName() + ": ");
        for (Card card : player.showCards()) {
            System.out.print(card + "\t");
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        Player[] playersArray = {new Player("jack"),
                                new Player("tony"),
                                new Player("ben "),
                                new Player("rose")};
//      Card card1 = new Card(Suite.SPADE, 5);
//      Card card2 = new Card(Suite.DIAMOND, 13);
//      Card card3= new Card(Suite.TRUMP, 15);
//      
//      System.out.println(card1);
//      System.out.println(card2);
//      System.out.println(card3);
        Poker poker = new Poker();
        poker.shuffle();
        for(int round = 1; round <= 3;round++){
            for (Player player : playersArray) {
                player.getOneCard(poker.deal());
            }
        }
        
        //显示每个玩家手上的牌
        for (Player player : playersArray) {
            display(player);
        }
//      while (poker.hasMoreCards()) {
//          System.out.println(poker.deal());
//          
//      }
    }
}

3. 定义一个机器人，给出随机数（猜数字游戏）

package org.mobilephone;
/**
 * 猜数字机器人
 * @author apple
 *
 */
public class Computer {

    private int answer;
    private String hint;
    private int counter;
    
    /**
     * 获取给用户的提示
     * @return 提示字符串
     */
    public String getHint() {
        return hint;
    }
    
    /**
     * 获取猜数字的次数
     * @return 次数
     */
    public int getCounter() {
        return counter;
    }
    
    /**
     * 构造器
     */
    public Computer(){
        this.reset();
    }
    
    /**
     * 判断有没有猜中数字
     * @param thyAnswer 玩家猜的数字
     * @return 如果猜中返回true，否则返回false
     */
    public boolean judge(int thyAnswer){
        counter += 1;
        if (thyAnswer == answer) {
            hint = "恭喜你，猜对了！";
            return true;
        }
        else if (thyAnswer > answer) {
            hint = "小一点";
        }
        else {
            hint = "大一点";
        }
        return false;
    }
    
    /**
     * 重置游戏（重新出随机数，计数器清零，提示清空）
     */
    public void reset(){
        answer = (int) (Math.random() * 100 + 1);
        counter = 0;
        hint = "";
    }
    
}

• 猜数字游戏的实现

package org.mobilephone;
import java.util.Scanner;
public class ComputerTest {
    public static void main(String[] args) {
        Computer computer = new Computer();
        Scanner input = new Scanner(System.in);
        boolean isAnswer = false;
        do {
            System.out.print("请输入(正整数):");
            int num = input.nextInt();
            isAnswer = computer.judge(num);
            System.out.println(computer.getHint());
        } while (!isAnswer);
        if (computer.getCounter() > 7) {
            System.out.println("智商捉急");
        }
        input.close();
    }
}