【韩顺平Java笔记】第8章：面向对象编程（中级部分）【338-342】

338. 零钱通消费

package com.masterspark.smallchange;


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

public class SmallChangeSys {
    public static void main(String[] args) {
        //1. 先完成显示菜单，并可以选择菜单，给出对应的提示
        //定义变量
        boolean loop = true;//是否需要循环显示
        Scanner scanner = new Scanner(System.in);
        String key = "";//输入的选择
        //完成零钱通明细
        //思路：（1）收益入账和消费保存到数组
        //（2）使用对象完成
        //（3）简单的话使用String拼接
        //使用第三个
        String details = "-------零钱通明细-------";
        //3. 完成收益入账
        //思路：定义新的变量，完成功能驱动程序员增加新的变化和代码
        double money = 0.0;
        double balance = 0.0;//🈷
        Date date = null;//data是java.util.date类型
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");//可以用于日期格式化的对象

        //4. 消费
        //定义新变量，保存消费的原因
        String note = "";


        do{
            System.out.println("=========零钱通菜单=========");
            System.out.println("\t\t\t1 零钱通明细");
            System.out.println("\t\t\t2 收益入账");
            System.out.println("\t\t\t3 消费情况");
            System.out.println("\t\t\t4 退出系统");
            System.out.print("请选择（1-4）");
            key = scanner.next();
            //使用siwtch分支结构
            switch(key){
                case "1":
                    System.out.println(details);
                    break;
                case "2":
                    System.out.print("收1益入账金额：");
                    money = scanner.nextDouble();
                    //money的值的范围应该校验一下
                    //一会再完善
                    balance += money;
                    //拼接收益入账信息到details
                    date  = new Date();//获取当前的日期
                    details += "\n收益入账\t+" + money + "\t" + sdf.format(date) + "\t" +balance;
                    System.out.println(details);
                    break;
                case "3":
                    System.out.print("消费金额：");
                    money = scanner.nextDouble();
                    System.out.print("消费说明：");
                    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":
                    System.out.println("------退出了零钱通-------");
                    loop=false;//退出循环
                    break;
                default:
                    System.out.println("菜单选择有误，请重新选择");
            }
        }while(loop);
    }
}

运行结果：
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）2
收1益入账金额：114514
-------零钱通明细-------
收益入账 +114514.0 2025-01-19 08:40 114514.0
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）3
消费金额：1919
消费说明：嗯嘛啊
-------零钱通明细-------
收益入账 +114514.0 2025-01-19 08:40 114514.0
嗯嘛啊 -1919.0 2025-01-19 08:40 112595.0
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）1
-------零钱通明细-------
收益入账 +114514.0 2025-01-19 08:40 114514.0
嗯嘛啊 -1919.0 2025-01-19 08:40 112595.0
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）4
------退出了零钱通-------

进程已结束，退出代码为 0

339. 零钱通退出确认

用户输入4退出时，给出提示是否退出y/n，否则继续输入，直到输入y或者n

package com.masterspark.smallchange;


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

public class SmallChangeSys {
    public static void main(String[] args) {
        //1. 先完成显示菜单，并可以选择菜单，给出对应的提示
        //定义变量
        boolean loop = true;//是否需要循环显示
        Scanner scanner = new Scanner(System.in);
        String key = "";//输入的选择
        //完成零钱通明细
        //思路：（1）收益入账和消费保存到数组
        //（2）使用对象完成
        //（3）简单的话使用String拼接
        //使用第三个
        String details = "-------零钱通明细-------";
        //3. 完成收益入账
        //思路：定义新的变量，完成功能驱动程序员增加新的变化和代码
        double money = 0.0;
        double balance = 0.0;//🈷
        Date date = null;//data是java.util.date类型
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");//可以用于日期格式化的对象

        //4. 消费
        //定义新变量，保存消费的原因
        String note = "";


        do{
            System.out.println("=========零钱通菜单=========");
            System.out.println("\t\t\t1 零钱通明细");
            System.out.println("\t\t\t2 收益入账");
            System.out.println("\t\t\t3 消费情况");
            System.out.println("\t\t\t4 退出系统");
            System.out.print("请选择（1-4）");
            key = scanner.next();
            //使用siwtch分支结构
            switch(key){
                case "1":
                    System.out.println(details);
                    break;
                case "2":
                    System.out.print("收1益入账金额：");
                    money = scanner.nextDouble();
                    //money的值的范围应该校验一下
                    //一会再完善
                    balance += money;
                    //拼接收益入账信息到details
                    date  = new Date();//获取当前的日期
                    details += "\n收益入账\t+" + money + "\t" + sdf.format(date) + "\t" +balance;
                    System.out.println(details);
                    break;
                case "3":
                    System.out.print("消费金额：");
                    money = scanner.nextDouble();
                    System.out.print("消费说明：");
                    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":
                    //用户输入4退出时，给出提示是否退出y/n，否则继续输入，直到输入y或者n
                    //思路：
                    //（1）定义一个变量（choice）
                    //（2）循环逻辑（while + break）来处理接收到的输入是y或者n
                    String choice = "";
                    //一段代码完成一个功能（不在while循环中写退出逻辑）
                    //尽量不要混在一起
                    while(true){
                        System.out.println("你确定要退出吗？y/n");
                        choice = scanner.next();
                        if("y".equals(choice) || "n".equals(choice)){
                            break;
                        }
                    }
                    //（3）用户退出while后再判断输入的是y还是n，就可以决定是否退出
                    if("y".equals(choice)){
                        System.out.println("------退出了零钱通-------");
                        loop=false;//退出循环
                    }
                    break;
                default:
                    System.out.println("菜单选择有误，请重新选择");
            }
        }while(loop);
    }
}

运行结果：
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）4
你确定要退出吗？y/n
n
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）4
你确定要退出吗？y/n
y
------退出了零钱通-------

进程已结束，退出代码为 0

=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）4
你确定要退出吗？y/n
p
你确定要退出吗？y/n
s
你确定要退出吗？y/n
y
------退出了零钱通-------

340. 零钱通金额校验

在收益入账和消费时，判断金额是否合理，并给出相应的提示

package com.masterspark.smallchange;


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

public class SmallChangeSys {
    public static void main(String[] args) {
        //1. 先完成显示菜单，并可以选择菜单，给出对应的提示
        //定义变量
        boolean loop = true;//是否需要循环显示
        Scanner scanner = new Scanner(System.in);
        String key = "";//输入的选择
        //完成零钱通明细
        //思路：（1）收益入账和消费保存到数组
        //（2）使用对象完成
        //（3）简单的话使用String拼接
        //使用第三个
        String details = "-------零钱通明细-------";
        //3. 完成收益入账
        //思路：定义新的变量，完成功能驱动程序员增加新的变化和代码
        double money = 0.0;
        double balance = 0.0;//🈷
        Date date = null;//data是java.util.date类型
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");//可以用于日期格式化的对象

        //4. 消费
        //定义新变量，保存消费的原因
        String note = "";


        do{
            System.out.println("=========零钱通菜单=========");
            System.out.println("\t\t\t1 零钱通明细");
            System.out.println("\t\t\t2 收益入账");
            System.out.println("\t\t\t3 消费情况");
            System.out.println("\t\t\t4 退出系统");
            System.out.print("请选择（1-4）");
            key = scanner.next();
            //使用siwtch分支结构
            switch(key){
                case "1":
                    System.out.println(details);
                    break;
                case "2":
                    System.out.print("收益入账金额：");
                    money = scanner.nextDouble();
                    //money的值的范围校验
                    //思路：把不正确的情况判断出来退出即可
                    if(money <= 0){
                        System.out.println("收益入账金额应大于0");
                        break;
                    }
                    //如果反过来找出正确的条件，要写if else，两个分支阅读起来不轻松
                    //如果还需要写正确条件，里面就要嵌套if else
                    balance += money;
                    //拼接收益入账信息到details
                    date  = new Date();//获取当前的日期
                    details += "\n收益入账\t+" + money + "\t" + sdf.format(date) + "\t" +balance;
                    System.out.println(details);
                    break;
                case "3":
                    System.out.print("消费金额：");
                    money = scanner.nextDouble();
                    if(money <= 0 || money > balance){
                        System.out.println("消费金额应该在0-" + balance);
                        break;
                    }
                    System.out.print("消费说明：");
                    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":
                    //用户输入4退出时，给出提示是否退出y/n，否则继续输入，直到输入y或者n
                    //思路：
                    //（1）定义一个变量（choice）
                    //（2）循环逻辑（while + break）来处理接收到的输入是y或者n
                    String choice = "";
                    //一段代码完成一个功能（不在while循环中写退出逻辑）
                    //尽量不要混在一起
                    while(true){
                        System.out.println("你确定要退出吗？y/n");
                        choice = scanner.next();
                        if("y".equals(choice) || "n".equals(choice)){
                            break;
                        }
                    }
                    //（3）用户退出while后再判断输入的是y还是n，就可以决定是否退出
                    if("y".equals(choice)){
                        System.out.println("------退出了零钱通-------");
                        loop=false;//退出循环
                    }
                    break;
                default:
                    System.out.println("菜单选择有误，请重新选择");
            }
        }while(loop);
    }
}

运行结果：
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）2
收益入账金额：-100
收益入账金额应大于0
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）2
收益入账金额：114514
-------零钱通明细-------
收益入账 +114514.0 2025-01-19 09:28 114514.0
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）3
消费金额：-100
消费金额应该在0-114514.0
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）3
消费金额：19191919
消费金额应该在0-114514.0
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）3
消费金额：10
消费说明：11
-------零钱通明细-------
收益入账 +114514.0 2025-01-19 09:28 114514.0
11 -10.0 2025-01-19 09:28 114504.0
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）4
你确定要退出吗？y/n
Y
你确定要退出吗？y/n
y
------退出了零钱通-------

341. 零钱通OOP版

将面向过程的代码修改成面向对象的，编写SmallChangeSysOOP.java类，并使用SmallChangeSysAPP.java完成测试。

SmallChangeSysOOP.java:

package com.masterspark.smallchange.oop;

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

/*
 * 该类是完成零钱通的各个功能
 * 使用OOP（面向对象编程）
 * 将各个功能对应一个方法
 */
public class SmallChangeSysOOP {
    //属性
    boolean loop = true;//是否需要循环显示
    Scanner scanner = new Scanner(System.in);
    String key = "";//输入的选择
    //完成零钱通明细
    //思路：（1）收益入账和消费保存到数组
    //（2）使用对象完成
    //（3）简单的话使用String拼接
    //使用第三个
    String details = "-------零钱通明细-------";
    //3. 完成收益入账
    //思路：定义新的变量，完成功能驱动程序员增加新的变化和代码
    double money = 0.0;
    double balance = 0.0;//🈷
    Date date = null;//data是java.util.date类型
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");//可以用于日期格式化的对象
    //4. 消费
    //定义新变量，保存消费的原因
    String note = "";
    //显示主菜单
    public void mainMenu(){
        do{
            System.out.println("=========零钱通菜单=========");
            System.out.println("\t\t\t1 零钱通明细");
            System.out.println("\t\t\t2 收益入账");
            System.out.println("\t\t\t3 消费情况");
            System.out.println("\t\t\t4 退出系统");
            System.out.print("请选择（1-4）");
            key = scanner.next();
            //使用siwtch分支结构
            switch(key){
                case "1":
                    this.detail();
                    break;
                case "2":
                    this.income();
                    break;
                case "3":
                    this.pay();
                    break;
                case "4":
                    //用户输入4退出时，给出提示是否退出y/n，否则继续输入，直到输入y或者n
                    //思路：
                    //（1）定义一个变量（choice）
                    //（2）循环逻辑（while + break）来处理接收到的输入是y或者n
                    String choice = "";
                    //一段代码完成一个功能（不在while循环中写退出逻辑）
                    //尽量不要混在一起
                    while(true){
                        System.out.println("你确定要退出吗？y/n");
                        choice = scanner.next();
                        if("y".equals(choice) || "n".equals(choice)){
                            break;
                        }
                    }
                    //（3）用户退出while后再判断输入的是y还是n，就可以决定是否退出
                    if("y".equals(choice)){
                        System.out.println("------退出了零钱通-------");
                        loop=false;//退出循环
                    }
                    break;
                default:
                    System.out.println("菜单选择有误，请重新选择");
            }
        }while(loop);
    }
    //完成零钱通明细
    public void detail(){
        System.out.println(details);
    }
    //完成收益入账
    public void income(){
        System.out.print("收益入账金额：");
        money = scanner.nextDouble();
        //money的值的范围校验
        //思路：把不正确的情况判断出来退出即可
        if(money <= 0){
            System.out.println("收益入账金额应大于0");
            return;
        }
        //如果反过来找出正确的条件，要写if else，两个分支阅读起来不轻松
        //如果还需要写正确条件，里面就要嵌套if else
        balance += money;
        //拼接收益入账信息到details
        date  = new Date();//获取当前的日期
        details += "\n收益入账\t+" + money + "\t" + sdf.format(date) + "\t" +balance;
        System.out.println(details);
    }
    //消费
    public void pay(){
        System.out.print("消费金额：");
        money = scanner.nextDouble();
        if(money <= 0 || money > balance){
            System.out.println("消费金额应该在0-" + balance);
            return;
        }
        System.out.print("消费说明：");
        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(){
        //用户输入4退出时，给出提示是否退出y/n，否则继续输入，直到输入y或者n
        //思路：
        //（1）定义一个变量（choice）
        //（2）循环逻辑（while + break）来处理接收到的输入是y或者n
        String choice = "";
        //一段代码完成一个功能（不在while循环中写退出逻辑）
        //尽量不要混在一起
        while(true){
            System.out.println("你确定要退出吗？y/n");
            choice = scanner.next();
            if("y".equals(choice) || "n".equals(choice)){
                break;
            }
        }
        //（3）用户退出while后再判断输入的是y还是n，就可以决定是否退出
        if("y".equals(choice)){
            System.out.println("------退出了零钱通-------");
            loop=false;//退出循环
        }
    }


}

SmallChangeSysAPP.java:

package com.masterspark.smallchange.oop;

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

运行结果：
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）2
收益入账金额：100
-------零钱通明细-------
收益入账 +100.0 2025-01-19 10:01 100.0
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）1
-------零钱通明细-------
收益入账 +100.0 2025-01-19 10:01 100.0
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）3
消费金额：10
消费说明：吃饭
-------零钱通明细-------
收益入账 +100.0 2025-01-19 10:01 100.0
吃饭 -10.0 2025-01-19 10:01 90.0
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）1
-------零钱通明细-------
收益入账 +100.0 2025-01-19 10:01 100.0
吃饭 -10.0 2025-01-19 10:01 90.0
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）2
收益入账金额：-10
收益入账金额应大于0
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）3
消费金额：-100
消费金额应该在0-90.0
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）3
消费金额：1000
消费金额应该在0-90.0
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）4
你确定要退出吗？y/n
s
你确定要退出吗？y/n
n
=========零钱通菜单=========
1 零钱通明细
2 收益入账
3 消费情况
4 退出系统
请选择（1-4）4
你确定要退出吗？y/n
y
------退出了零钱通-------

342. 本章作业01

定义一个Person类(name, age, job)，初始化Person对象数组，有3个person对象，并按照age从大到小进行排序，使用冒泡排序


import java.util.Arrays;

//TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or
// click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
public class Main {
    public static void main(String[] args) {
        //debug动态绑定机制
        Person[] people = new Person[3];
        people[0] = new Person("田所浩二", 24, "学生");
        people[1] = new Person("德川", 26, "美食家");
        people[2] = new Person("我修院", 25, "美食家");
        //输出当前对象数组
        for(int i = 0; i < people.length; i++){
            System.out.println(people[i]);
        }
        //使用冒泡排序
        Person tmp = null;//交换用的临时变量
        for(int i = 0; i < people.length; i++){
            for(int j = 0;  j < people.length - i -1 ; j++){//从大到小排
                //j每次从头遍历到i的前一个位置
                //如果前面的人年龄小于后面的就交换
                if(people[i].getAge() < people[j].getAge()){
                    tmp = people[i];
                    people[i] = people[i+1];
                    people[i+1] = tmp;
                }
            }
        }
        //输出当前对象数组
        for(int i = 0; i < people.length; i++){
            System.out.println(people[i]);
        }
    }
}
class Person{
    private String name;
    private int age;
    private String job;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public Person(String name, int age, String job) {
        this.name = name;
        this.age = age;
        this.job = job;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", job='" + job + '\'' +
                '}';
    }
}

运行结果：
Person{name=‘田所浩二’, age=24, job=‘学生’}
Person{name=‘德川’, age=26, job=‘美食家’}
Person{name=‘我修院’, age=25, job=‘美食家’}
Person{name=‘德川’, age=26, job=‘美食家’}
Person{name=‘我修院’, age=25, job=‘美食家’}
Person{name=‘田所浩二’, age=24, job=‘学生’}