零钱通项目（java）

1.项目需求说明

使用 Java 开发 零钱通项目 , 可以完成收益入账，消费，查看明细，退出系统等功能。

2.项目的界面

化繁为简

1. 先完成显示菜单，并可以选择

2. 完成零钱通明细.

3. 完成收益入账

4. 消费

5. 退出

​ 先使用过程编程，后面改成 OOP 版本，请小伙伴体会 OOP 编程带来的好处

3.编程思想积累

1. while + break
2. if + break(游戏过关思想)

4.面向过程编写

package com.yt.change;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class ChangeSys {
    public static void main(String[] args) {
        //化繁为简
        //1. 先完成显示菜单，并可以选择菜单，给出对应提示
        //2. 完成零钱通明细
        //3. 完成收益入账
        //4. 消费
        //5. 退出
        //6. 用户输入4退出时，给出提示"你确定要退出吗? y/n"，必须输入正确的y/n ，否则循环输入指令，直到输入y 或者 n
        //7. 在收益入账和消费时，判断金额是否合理，并给出相应的提示

        //2.使用字符串拼接
        //(1)可以把收益入账和消费保存到数组
        //(2)可以使用对象
        //(3)简单使用字符串拼接
        String details = "\n---------零钱通明细-----------";

        //3.完成收益入账
        //定义新的变量
        double money = 0;
        double balance = 0;
        Date date = null;//date 是java.util.Date类型，表示日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");//可以用于日期格式化

        //4.消费
        //消费说明
        String note = "";

        boolean flag = true;
        do {
            //1. 先完成显示菜单，并可以选择菜单，给出对应提示
            System.out.println("\n=========零钱通菜单=========");
            System.out.println("\t1 零钱通明细");
            System.out.println("\t2 收益入账");
            System.out.println("\t3 消费");
            System.out.println("\t4 退    出");
            System.out.print("请选择(1-4):");

            // 需要实现循环输入
            Scanner scanner = new Scanner(System.in);
            String key = scanner.next();

            switch (key){
                case "1":
//                    System.out.println("零钱通明细");
                    System.out.println(details);
                    break;
                case "2":
//                    System.out.println("收益入账");
                    System.out.print("收益入账金额：");
                    money = scanner.nextDouble();
                    //money的值应该校验
                    //代码建议：通常思考不正确的逻辑
                    //找出不正确的金额条件，然后给出提示，就直接break
                    if (money < 0) {
                        System.out.println("输入的金额不正确，需要大于零，请重新输入");
                        break;
                    }
                    //这样的便利在于，如果还有其他不正确的条件，直接加逻辑就行，不用很多个分支造成可读性很差，就像闯关一样

                    balance += money;
                    date = new Date();
//                    System.out.println(sdf.format(date));
                    details += "\n收益入账\t+" + money + "\t" + sdf.format(date) + "\t" + balance;
                    System.out.println(details);
                    break;
                case "3":
//                    System.out.println("消费");
                    System.out.print("消费金额：");
                    money = scanner.nextDouble();
                    //money的值应该校验
                    //找出不正确的金额条件，然后给出提示，就直接break
                    if (money <=0 || money > balance){
                        System.out.println("消费金额应该在 0-" + balance);
                        break;
                    }
                    System.out.println("消费说明");
                    note = scanner.next();
                    balance -= money;
                    date = new Date();
                    details += "\n" + note + "\t-" + money + "\t" + sdf.format(date) + "\t" + balance;
                    System.out.println(details);
                    break;
                case "4":
                    //6. 用户输入4退出时，给出提示"你确定要退出吗? y/n"，必须输入正确的y/n ，否则循环输入指令，直到输入y 或者 n
                    //思路
                    //(1)定义一个变量choice,接收用户的输入
                    //(2)使用while + break来处理接收到的是y或是n
                    //(3)退出while后，再判断choice是y还是n，决定是否要退出
                    //(4)建议一段代码完成一个功能，尽量不要混在一起：高内聚低耦合

                    String choice = "";
                    while (true){
                        System.out.println("你确定要退出吗？y/n");
                        choice = scanner.next();
                        if (choice.equals("y") || choice.equals("n")){
                            break;
                        }
                        //第二个方案
//                        if("y".equals(choice)) {
//                            loop = false;
//                            break;
//                        } else if ("n".equals(choice)) {
//                            break;
//                        }
                    }
                    //跳出前面的循环意味着输入的是y/n
                    if (choice.equals("y")){
                        flag = false;
                    }


                    //flag = false;
                    break;
                default:
                    System.out.println("输入有误，请重新选择！");
            }

        } while (flag);

        System.out.println("======退出了零钱通项目======");
    }
}

5.面向对象编写

public class ChangeSysAPP {
    public static void main(String[] args) {
        new ChangeSysOOp().mainMenu();
    }
}

package com.yt.change.oop;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class ChangeSysOOp {
    //化繁为简
    //1. 先完成显示菜单，并可以选择菜单，给出对应提示
    //2. 完成零钱通明细
    //3. 完成收益入账
    //4. 消费
    //5. 退出
    //6. 用户输入4退出时，给出提示"你确定要退出吗? y/n"，必须输入正确的y/n ，否则循环输入指令，直到输入y 或者 n
    //7. 在收益入账和消费时，判断金额是否合理，并给出相应的提示

    //2.使用字符串拼接
    //(1)可以把收益入账和消费保存到数组
    //(2)可以使用对象
    //(3)简单使用字符串拼接
    String details = "\n---------零钱通明细-----------";

    //3.完成收益入账
    //定义新的变量
    double money = 0;
    double balance = 0;
    Date date = null;//date 是java.util.Date类型，表示日期
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");//可以用于日期格式化

    //4.消费
    //消费说明
    String note = "";

    Scanner scanner = new Scanner(System.in);
    String key = "";

    boolean flag = true;

    //完成零钱通明细
    public void mainMenu(){
        do {
            //1. 先完成显示菜单，并可以选择菜单，给出对应提示
            System.out.println("\n=========零钱通菜单(OOP)=========");
            System.out.println("\t1 零钱通明细");
            System.out.println("\t2 收益入账");
            System.out.println("\t3 消费");
            System.out.println("\t4 退    出");
            System.out.print("请选择(1-4):");

            String key = scanner.next();

            switch (key){
                case "1":
                    this.detail();
                    break;
                case "2":
                    this.income();
                    break;
                case "3":
                    this.pay();
                    break;
                case "4":
                    this.exit();
                    break;
                default:
                    System.out.println("输入有误，请重新选择！");
            }

        } while (flag);
    }
    public void detail(){
        System.out.println(details);
    }

    //完成收益入账
    public void income(){
        System.out.print("收益入账金额：");
        money = scanner.nextDouble();
        //money的值应该校验
        //代码建议：通常思考不正确的逻辑
        //找出不正确的金额条件，然后给出提示，就直接break
        if (money < 0) {
            System.out.println("输入的金额不正确，需要大于零，请重新输入");
            return;
        }
        //这样的便利在于，如果还有其他不正确的条件，直接加逻辑就行，不用很多个分支造成可读性很差，就像闯关一样

        balance += money;
        date = new Date();
//                    System.out.println(sdf.format(date));
        details += "\n收益入账\t+" + money + "\t" + sdf.format(date) + "\t" + balance;
        System.out.println(details);
    }

    // 消费
    public void pay() {
        System.out.print("消费金额：");
        money = scanner.nextDouble();
        //money的值应该校验
        //找出不正确的金额条件，然后给出提示，就直接break
        if (money <=0 || money > balance){
            System.out.println("消费金额应该在 0-" + balance);
            return;
        }
        System.out.println("消费说明");
        note = scanner.next();
        balance -= money;
        date = new Date();
        details += "\n" + note + "\t-" + money + "\t" + sdf.format(date) + "\t" + balance;
        System.out.println(details);
    }

    public void exit() {
        //6. 用户输入4退出时，给出提示"你确定要退出吗? y/n"，必须输入正确的y/n ，否则循环输入指令，直到输入y 或者 n
        //思路
        //(1)定义一个变量choice,接收用户的输入
        //(2)使用while + break来处理接收到的是y或是n
        //(3)退出while后，再判断choice是y还是n，决定是否要退出
        //(4)建议一段代码完成一个功能，尽量不要混在一起：高内聚低耦合

        String choice = "";
        while (true){
            System.out.println("你确定要退出吗？y/n");
            choice = scanner.next();
            if (choice.equals("y") || choice.equals("n")){
                break;
            }
            //第二个方案
//                        if("y".equals(choice)) {
//                            loop = false;
//                            break;
//                        } else if ("n".equals(choice)) {
//                            break;
//                        }
        }
        //跳出前面的循环意味着输入的是y/n
        if (choice.equals("y")){
            flag = false;
        }
    }

}