【JavaSE】面向对象中级学习笔记

面向对象中级

-IDE（集成开发环境）-IDEA

• IDEA介绍

  1. IDEA 全称 IntelliJ IDEA
  2. 在业界被公认为最好的Java开发工具
  3. IDEA是JetBrains公司的产品，总部位于捷克的首都布拉格
  4. 除了支持Java开发，还支持HTML，CSS，PHP，MySQL，Python等

• Eclipse介绍

  1. Eclipse 是一个开放源代码的、基于Java的可扩展开发平台
  2. 最初是由IBM 公司耗资3000万美金开发的下一代IDE开发环境
  3. 2001年11月贡献给开源社区又
  4. Eclipse是目前最优秀的Java开发IDE之一

• IDEA的安装

  • 官网: https://www.jetbrains.com/

• IDEA使用技巧和经验

  • 设置字体

• IDEA常用快捷键（在设置中使用Eclipse配置即可）

  • 删除当前行 ctrl+D
  • 复制当前行,自己配置 ctrl + alt + 向下光标
  • 补全代码 alt +/
  • 添加注释和取消注释 ctrl +/【第一次是添加注释，第二次是取消注释】
  • 导入该行需要的类 先配置auto import，然后使用 alt+enter即可
  • 快速格式化代码 ctrl + shift +L
  • 快速运行程序 自己定义 alt + R
  • 生成构造方法等 alt + insert[提高开发效率]
  • 查看一个类的层级关系 ctrl +H[学习继承后，非常有用]
  • 自动的分配变量名，通过 在后面 .var
  • 将光标放在一个方法上，输入 ctrl+B,可以选择定位到哪个类的方法
  • 还有很多其它的快捷键…

• 模板/自定义模板

  file -> settings -> editor-> Live templates ->查看有哪些模板快捷键/可以自己增加模板

  模板可以高效的完成开发

-包

• 包的三大作用

  1. 区分相同名字的类
  2. 当类很多时,可以很好的管理类[看Java API 文档]
  3. 控制访问范围

• 包基本语法
  package com.hspedu;

  说明:

  1. package 关键字,表示打包
  2. com.hspedu: 表示包名

• 包的本质分析(原理)
  包的本质实际上就是创建不同的文件夹来保存类文件

• 包的命名

  • 命名规则:只能包含数字、字母、"下划线、小圆点.,但不能用数字开头，不能是关键字或保留字

    demo.class.exec1//不能是关键字

    demo.12a//不能用数字开头

    demo.ab12.oa//可以

  • 命名规范

    一般是小写字母+小圆点一般是

    com.公司名.项目名.业务模块名

    比如:com.hspedu.oa.model;com.hspedu.oa.controller,

    举例:
    com.sina.crm.user //用户模块com.sina.crm.order//订单模块com.sina.crm.utils//工具类

• 常用的包

  一个包下,包含很多的类,java中常用的包有:

  • java.lang.//lang包是基本包，默认引入，不需要再引入
  • java.util.*//util 包，系统提供的工具包,工具类，使用 Scanner**
  • **java.net.*//网络包，网络开发
  • java.awt.*//是做java的界面开发，GUI

• 如何引入包

  com.hspedu.pkg :lmport01.java

  语法: import 包;

  我们引入一个包的主要目的是要使用该包下的类

  比如 import java.util.Scanner; 就只是引入一个类Scanner。

  import java.util.*😕/ 表示将java.util 包所有都引入

  案例: 使用系统提供 Arrays 完成 数组排序

• 注意事项和使用细节

  1. package 的作用是声明当前类所在的包，需要放在class的最上面，一个类中最多只有一句package
  2. import指令 位置放在package的下面，在类定义前面,可以有多句且没有顺序要求。

-访问修饰符

• 基本介绍

  java提供四种访问控制修饰符号控制方法和属性(成员变量)的访问权限(范围)

  1. 公开级别:用public 修饰,对外公开
  2. 受保护级别:用protected修饰,对子类和同一个包中的类公开
  3. 默认级别:没有修饰符号,向同一个包的类公开.
  4. 私有级别:用private修饰,只有类本身可以访问,不对外公开

• 使用的注意事项

  1. 修饰符可以用来修饰类中的属性，成员方法以及类
  2. 只有默认的和public才能修饰类!，并且遵循上述访问权限的特点。
  3. 因为没有学习继承，因此关于在子类中的访问权限，我们讲完子类后，在回头讲解
  4. 成员方法的访问规则和属性完全一样.

-面向对象三大特征-封装、继承、多态

• 基本介绍

  面向对象三大特征：封装、继承、多态

-封装

• 封装介绍
  封装(encapsulation)就是把抽象出的数据[属性]和对数据的操作[方法]封装在一起,数据被保护在内部,程序的其它部分只有通过被授权的操作[方法],才能对数据进行操作。

• 封装的理解和好处

  1. 隐藏实现细节，通过调用方法传入参数实现功能

  2. 可以对数据进行验证，保证安全合理

     Person {name, age}

• 封装的实现步骤

  1. 将属性进行私有化【不能直接修改属性】

  2. 提供一个公共的set方法，用于对属性判断并赋值

     public void setXxx(类型 参数名){
     ​	//加入数据验证的业务逻辑
     ​	属性 = 参数名;
     }
     

  3. 提供一个公共的get方法，用于获取属性的值

     public XX getXxx(){//权限判断
     ​	return xx;
     }
     

• 将构造器和set方法结合

  this.setName(name);
  this.setAge(age);
  this.setJob(job);
  this.setsalary(salary);
  

• 练习

  创建程序,在其中定义两个类:Account和AccountTest类体会Java的封装性。

  1. Account类要求具有属性:姓名(长度为2位3位或4位)、余额(必须>20)密码(必须是六位)，如果不满足，则给出提示信息，并给默认值
  2. 通过setXxx的方法给Account 的属性赋值。
  3. 在AccountTest中测试

package com.xijie.encap;

public class AccountTest {
    public static void main(String[] args) {
        //测试正常情况
        Account account0 = new Account("小明", "999999", 100);
        System.out.println("accountname: "+account0.getAccountName() + " balance: "+account0.getBalance() + " password: "+account0.getPassword());
        //测试不正常情况
        Account account1 = new Account("小明1111", "9999990", 15);
        System.out.println("accountname: "+account1.getAccountName() + " balance: "+account1.getBalance() + " password: "+account1.getPassword());
    }
}

package com.xijie.encap;

/**
 * 1. Account类要求具有属性:姓名(长度为2位3位或4位)、余额(必须>20)密码(必须是六位)，如果不满足，则给出提示信息，并给默认值
 * 2. 通过setXxx的方法给Account 的属性赋值。
 */
public class Account {
    private String accountName;//姓名
    private String password;//密码
    private int balance;//余额

    public Account(String accountName, String password, int balance) {
        this.setAccountName(accountName);
        this.setPassword(password);
        this.setBalance(balance);
    }

    public int getBalance() {
        return balance;
    }

    public void setBalance(int balance) {
        //必须>20
        if(balance<=20){
            System.out.println("余额需要大于20，设置默认值21");
            this.balance = 21;
        }else{
            this.balance = balance;
        }
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        //必须是六位
        if(password.length()!=6){
            System.out.println("密码必须是6位,设置默认值888888");
            this.password = "888888";
        }else{
            this.password = password;
        }
    }

    public String getAccountName() {
        return accountName;
    }

    public void setAccountName(String accountName) {
        //TODO:姓名长度为2位3位或4位
        int accountNameLength = accountName.length();
        if(accountNameLength>4||accountNameLength<2){
            System.out.println("姓名长度需要为2位3位或4位，设置默认值AAA");
            this.accountName = "AAA";
        }else{
            this.accountName = accountName;
        }
    }
}

-继承

• 为什么需要继承

  一个小问题,还是看个程序[com.hspedu.extend 包: Extends01.java]提出代码复用的问题。

  一个是Pupil 类(小学生)，我们编写了两个类，一个是Graduate(研究生)问题: 两个类的属性和方法有很多是相同的，怎么办?

  继承：代码复用性

• 继承基本介绍和示意图

  继承可以解决代码复用,让我们的编程更加靠近人类思维,当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类,在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends来声明继承父类即可。

• 继承的基本语法

  class 子类 extends 父类{

  }

  1. 子类就会自动拥有父类定义的属性和方法
  2. 父类又叫 超类，基类
  3. 子类又叫派生类。

• 继承的注意事项和细节

  1. 子类继承了所有的属性和方法，但是私有属性不能在子类直接访问，要通过父类公共的方法去访问
  2. 子类必须调用父类的构造器,完成父类的初始化
  3. 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过
  4. 如果希望指定去调用父类的某个构造器，则显式的调用一下
  5. super在使用时，需要放在构造器第一行
  6. super() 和 this()都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
  7. Java所有类都是Object类的子类
  8. 父类构造器的调用不限于直接父类！将一直网上追溯直到Object类（顶级父类）
  9. 子类最多只能继承一个父类(指直接继承)，即java中是单继承机制。思考:如何让A类继承B类和C类
  10. 不能滥用继承，子类和父类之间必须满足 is-a 的逻辑关系

• 继承的本质分析

​ 在创建一个对象时，会在方法区中按顶级父类到子类的顺序检查是否加载了对应的类，并逐级加载。在堆中为对象开辟空间，并在该空间中从顶级父类到子类的顺序在堆中加载成员变量。而所有方法都存储在方法区中。

• 继承练习

package com.xijie.ext;
/**
 * 编写Computer类，包含CPU、内存、硬盘等属性，getDetails方法用于返回Computer的详细信息
 * 编写PC子类，继承Computer类，添加特有属性【品牌brand)
 * 编写NotePad子类，继承Computer类，添加特有属性【演示color)
 * 编写Test类，在main方法中创建PC和NotePad对象，分别给对象中特有的属性赋值，以及从Computer类继承的属性赋值，并使用方法并打印输出信息。
 */
public class ExtendsExercise {
    public static void main(String[] args) {
        System.out.println("hello");
    }
}

package com.xijie.ext;

/**
 * 编写Computer类，包含CPU、内存、硬盘等属性，getDetails方法用于返回Computer的详细信息
 */
public class Computer {
    private String cpu;
    private String disk;
    private String memory;

    Computer(){
        //默认的CPU、硬盘、内存都是无
        this("无","无","无");
    }

    Computer(String cpu, String disk, String memory) {
        this.cpu = cpu;
        this.disk = disk;
        this.memory = memory;
    }

    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public String getDisk() {
        return disk;
    }

    public void setDisk(String disk) {
        this.disk = disk;
    }

    public String getMemory() {
        return memory;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    /**
     * 获取CPU、硬盘、内存信息
     * @return
     */
    public String getDetail(){
        return "CPU："+cpu+" 硬盘："+disk+" 内存："+memory;
    }
}

package com.xijie.ext;

/**
 * 编写PC子类，继承Computer类，添加特有属性【品牌brand)
 */
public class PC extends Computer{
    private String brand;

    public PC(){
        this.brand = "无";
    }

    public PC(String brand) {
        this.brand = brand;
    }

    public PC(String cpu, String disk, String memory, String brand) {
        super(cpu, disk, memory);
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getDetail(){
        return super.getDetail()+" 品牌："+brand;
    }
}

package com.xijie.ext;

/**
 * 编写NotePad子类，继承Computer类，添加特有属性【演示color)
 */
public class NotePad extends Computer{
    private String color;

    public NotePad(){
        this.color = "无";
    }

    public NotePad(String color) {
        this.color = color;
    }

    public NotePad(String cpu, String disk, String memory, String color) {
        super(cpu, disk, memory);
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getDetail(){
        return super.getDetail()+" 颜色："+color;
    }
}

-super关键字

• 基本介绍

  super代表父类的引用，用于访问父类的属性、方法、构造器

• 基本语法

  1. 访问父类的属性，但不能访问父类的private属性

     super.属性名:

  2. 访问父类的方法，不能访问父类的private方法

     super.方法名(参数列表);

  3. 访问父类的构造器(这点前面用过):

     super(参数列表);只能放在构造器的第一句，只能出现一句!

• super给编程带来的便利/细节

  1. 调用父类的构造器的好处(分工明确,父类属性由父类初始化，子类的属性由子类初始化)
  2. 当子类中有和父类中的成员(属性和方法)重名时，为了访问父类的成员，必须通过super。如果没有重名使用super、this、直接访问是一样的效果!
  3. super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员;如果多个基类中都有同名的成员，使用super访问遵循就近原则。A->B->C

• super和this的比较

  No.	区别点	this	super
  1	访问属性	访问本类中的属性，如果本类没有此属性则从父类中继续查找	访问父类中的属性
  2	调用方法	访问本类中的方法，如果本类没有此方法则从父类继续查找	直接访问父类中的方法
  3	调用构造器	调用本类构造器，必须放在构造器的首行	调用父类构造器，必须放在子类构造器的首行
  4	特殊	表示当前对象	子类中访问父类对象

-方法重写/覆盖

• 基本介绍
  简单的说:方法覆盖(重写)就是子类有一个方法,和父类的某个方法的名称、返回类型、参数一样,那么我们就说子类的这个方法覆盖了父类的那个方法

• 注意事项和使用细节
  方法重写也叫方法覆盖，需要满足下面的条件

  1. 子类的方法的参数,方法名称,要和父类方法的参数,方法名称完全一样。

  2. 子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子

     类比如 父类 返回类型是 Object ,子类方法返回类型是String演示
     public object getInfo(){
public string getInfo(){

  3. 子类方法不能缩小父类方法的访问权限
     void sayok(){
public woid sayok(){

• 重载和重写的比较

  名称	范围	方法名	参数列表	返回类型	修饰符
  重载	本类	相同	顺序、类型、个数至少有一个不同	无要求	无要求
  重写	子类和父类之间	相同	相同	子类重写方法的返回类型和父类一致或者是其子类	子类方法的权限范围要大于等于父类的

• 方法重写练习

package com.xijie.override;

/**
 * 编写一个Person类，包括属性/private(name、age)，构造器、方法say(返回自我介绍的字符串)
 * 编写一个Student类，继承Person类，增加id、score属性/private，以及构造器，定义say方法(返回自我介绍的信息)。
 * 在main中,分别创建Person和Student对象，调用say方法输出自我介绍。
 */
public class OverrideExercise {
    public static void main(String[] args) {
        Person person = new Person("小华",15);
        Student student = new Student("小刘",16,"123456",88);
        System.out.println(person.say());
        System.out.println(student.say());
    }
}

package com.xijie.override;

/**
 * 编写一个Person类，包括属性/private(name、age)，构造器、方法say(返回自我介绍的字符串)
 */
public class Person {
    private String name;
    private int age;

    /**
     * 默认名字：无名氏
     * 默认年龄：0
     */
    public Person() {
        this("无", 0);
    }

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

    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 say(){
        return "大家好，我叫" + name + "，今年" + age + "岁了！";
    }
}

package com.xijie.override;

/**
 * 编写一个Student类，继承Person类，增加id、score属性/private，以及构造器，定义say方法(返回自我介绍的信息)。
 */
public class Student extends Person{
    private String id;
    private double score;

    /**
     * 无参构造，默认id为000000，score为0
     */
    public Student(){
        this.id="000000";
        this.score=0;
    }

    public Student(String id, double score) {
        this.id = id;
        this.score = score;
    }

    public Student(String name, int age, String id, double score) {
        super(name, age);
        this.id = id;
        this.score = score;
    }

    public String say(){
        return super.say()+"我的学号是"+id+"，我考了"+score+"分！";
    }
}

-多态

• 一个问题

​ 问题是: 代码的复用性不高，而且不利于代码维护
​ 解决方案: 引出我们要讲解的多态

• 多态基本介绍

  方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的。

• 多态的具体体现

  1. 方法的多态

  2. 对象的多态

     重要的几句话

     1. 一个对象的编译类型和运行类型可以不一致
     2. 编译类型在定义对象时，就确定了，不能改变
     3. 运行类型是可以变化的
     4. 编译类型看定义时=号 的左边，运行类型看 =号的右边

• 多态的注意事项和细节讨论

  • 多态的前提是:两个对象(类)存在继承关系
  • 多态的向上转型

  1. 本质:父类的引用指向了子类的对象

  2. 语法:,父类类型 引用名=new 子类类型();

  3. 特点:编译类型看左边，运行类型看右边。

     可以调用父类中的所有成员(需遵守访问权限)

     不能调用子类中特有成员:

     最终运行效果看子类的具体实现!

  • 多态的向下转型
  1. 语法:子类类型 引用名=(子类类型)父类引用;
  2. 只能强转父类的引用，不能强转父类的对象
  3. 要求父类的引用必须指向的是当前目标类型的对象
  4. 可以调用子类类型中所有的成员
  • 属性没有重写之说!属性的值看编译类型
  • instanceOf 比较操作符，用于判断对象的类型是否为XX类型或XX类型的子类型【举例说明】

• Java的动态绑定机制

  1. 当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定
  2. 当调用对象属性时，没有动态绑定机制，哪里声明，那里使用

• 多态的应用

  1. 多态数组：数组的定义类型为父类类型，里面保存的实际元素为子类类型；若需要调用子类特有的方法，可以使用instanceof判断运行类型后再向下转型后调用
  2. 多态参数：方法定义的形参类型为父类类型，实参类型为子类类型

-Object类详解

• equals方法

  • ==和equals对比：
    • ==：既可以判断基本类型，又可以判断引用类型；如果判断基本类型，判断的是值是否相等；如果判断引用类型，判断的是地址是否相等。
    • equals：是Object类中的方法，只能判断引用类型；默认判断地址是否相等，可重写用于判断内容是否相等。

• hashCode方法

  • 提高具有哈希结构的容器的效率!
  • 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的!
  • 两个引用，如果指向的是不同对象，则哈希值是不一样的
  • 哈希值主要根据地址号来的!，不能完全将哈希值等价于地址
  • 后面在集合，中hashcode 如果需要的话，也会重写

• toString方法

  • 基本介绍

    默认返回:全类名+@+哈希值的十六进制，【查看Object 的 toString方法)

    子类往往重写toString方法，用于返回对象的属性信息

    public string tostring(){
        return getclass().getName()+"@"+ Integer,toHexString(hashcode());
    }
    

  • 重写toString方法，打印对象或拼接对象时，都会自动调用该对象的toString形式

  • 当直接输出一个对象时，toString 方法会被默认的调用

• finalize方法

1. 当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法做一些释放资源的操作
2. 什么时候被回收:当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finalize方法。
3. 垃圾回收机制的调用，是由系统来决定，也可以通过System.gc()主动触发垃圾回收机制，测试:Car [name]

-断点调试

• 一个实际需求

  1. 在开发中，新手程序员在查找错误时,这时老程序员就会温馨提示，可以用断点调试-步一步的看源码执行的过程，从而发现错误所在。
  2. 重要提示: 在断点调试 过程中，是运行状态，是以对象的 运行类型来执行的.

• 断点调试介绍

  1. 断点调试是指在程序的某一行设置一个断点，调试时，程序运行到这一行就会停住，然后你可以一步一步往下调试，调试过程中可以看各个变量当前的值，出错的话，调试到出错的代码行即显示错误，停下。进行分析从而找到这个Bug
  2. 断点调试是程序员必须掌握的技能。
  3. 断点调试也能帮助我们查看java底层源代码的执行过程，，提高程序员的Java水平

• 断点调试的快捷键:

  F7(跳入)F8(跳过)

  shift+F8(跳出)

  F9(resume,执行到下一个断点)

  F7:跳入方法内（可用于探寻Java源码）

  F8:逐行执行代码

  shift+F8:跳出方法

-零钱通项目练习

需求：

1. 主菜单包含零钱通明细、收益入账、消费、退出四个选项；

2. 零钱明细包含费用说明、金额、日期时间、余额四项信息；

3. 用户想要退出时检查输入指令是否正确，不正确则循环输入指令；

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

5. 使用面向对象的思维编程

   package com.xijie.smallChangeSys;
   
   /**
    * 运行入口类
    *  需求：
    *  1. 主菜单包含零钱通明细、收益入账、消费、退出四个选项；
    *  2. 零钱明细包含费用说明、金额、日期时间、余额四项信息；
    *  3. 用户想要退出时检查输入指令是否正确，不正确则循环输入指令；
    *  4. 收益入账和消费时判断金额是否合理，并给出相应提示
    *  5. 使用面向对象的思维编程
    */
   public class SmallChangeSysApp {
       public static void main(String[] args) {
           SmallChangeSys s = new SmallChangeSys();
           s.sysEntry();
       }
   }
   
   

   package com.xijie.smallChangeSys;
   
   import java.util.Scanner;
   
   /**
    * 实现类
    *  需求：
    *  1. 主菜单包含零钱通明细、收益入账、消费、退出四个选项；
    *  2. 零钱明细包含费用说明、金额、日期时间、余额四项信息；
    *  3. 用户想要退出时检查输入指令是否正确，不正确则循环输入指令；
    *  4. 收益入账和消费时判断金额是否合理，并给出相应提示
    *  5. 使用面向对象的思维编程
    */
   public class SmallChangeSys {
       //获取输入的对象
       Scanner sc = new Scanner(System.in);
       //明细列表对象
       DetailsList detailsList = new DetailsList();
   
       /**
        * 系统入口方法
        */
       public void sysEntry(){
           this.sysController();
       }
   
       /**
        * 系统循环控制器
        */
       public void sysController(){
           boolean loop=true;//循环控制标记
           do {
               this.printMainMenu();
               switch (sc.nextLine()){
                   case "1":
                       this.showDetails();
                       break;
                   case "2":
                       this.addIncome();
                       break;
                   case "3":
                       this.spendIncome();
                       break;
                   case "4":
                       loop=!this.exitConfirm();
                       break;
                   default:
                       break;
               }
           }while(loop);
       }
   
       /**
        * 输出主菜单
        */
       private void printMainMenu(){
           System.out.print(
                   "-----------零钱通主菜单-----------\n"+
                           "           1.明   细\n"+
                           "           2.收益入账\n"+
                           "           3.消   费\n"+
                           "           4.退   出\n"+
                           "请选择（1-4）："
           );
       }
   
       /**
        * 展示明细
        */
       private void showDetails(){
           System.out.println("------------零钱通明细------------");
           System.out.println(detailsList.toString());
       }
   
       /**
        * 收益入账
        */
       private void addIncome(){
           System.out.print("请输入收益金额：");
           String incomeStr=sc.nextLine();
           double income=Double.parseDouble(incomeStr);
           if(income<=0){
               System.out.println("金额应是正数");
               return;
           }
           detailsList.addDetail("收益入账",income);
       }
   
       /**
        * 消费
        */
       private void spendIncome() {
           System.out.print("请输入消费事项：");
           String reason=sc.nextLine();
           System.out.print("请输入金额：");
           String incomeStr=sc.nextLine();
           double spend=Double.parseDouble(incomeStr);
           if(spend<=0){
               System.out.println("金额应是正数");
               return;
           }
           if(spend>detailsList.getLatestBalance()){
               System.out.println("余额不足");
               return;
           }
           detailsList.addDetail(reason,-spend);
       }
   
       /**
        * 退出询问及确认
        */
       private boolean exitConfirm() {
           String exitInput;
           do {
               System.out.print("你确定要退出吗？（y/n）：");//输出用户提示
               exitInput = sc.nextLine();//获取输入
           } while (!"y".equals(exitInput) && !"n".equals(exitInput));
           return !"n".equals(exitInput);
       }
   }
   
   

​

package com.xijie.smallChangeSys;

import java.util.ArrayList;
import java.util.Date;

/**
 * 明细列表类，负责列表存储及输出拼接功能
 */
public class DetailsList {
    private final ArrayList<DetailItem> detailsList;

    DetailsList() {
        //初始化明细列表
        this.detailsList = new ArrayList<>();
    }

    /**
     * 添加明细记录
     * 要求：
     * amount不为0，否则返回1
     * date不为空，否则返回2
     * date获取当前时间
     * balance计算生成
     */
    public void addDetail(String reason, double amount){
        //获取最近历史余额
        double latestBalance = getLatestBalance();
        //计算新余额
        double newBalance=latestBalance+amount;
        //添加交易数据
        detailsList.add(new DetailItem(reason,amount,new Date(),newBalance));
    }

    /**
     * 获取最近历史余额
     * @return 最近历史余额
     */
    public double getLatestBalance() {
        //如果没有明细数据则返回0
        if(detailsList.isEmpty()){
            return 0;
        }
        //如果有明细数据则返回最后一条数据的balance
        return detailsList.get(detailsList.size() - 1).getBalance();
    }

    @Override
    public String toString() {
        StringBuilder str= new StringBuilder();
        for (DetailItem detailItem : detailsList) {
            str.append(detailItem.toString()).append("\n");
        }
        return str.toString();
    }
}

package com.xijie.smallChangeSys;

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.Date;

/**
 * 明细类，负责储存单条明细及单条明细信息拼接
 */
public class DetailItem {
    private String reason;//交易原因
    private double amount;//交易金额
    private Date date;//日期
    private double balance;//余额

    public DetailItem(String reason, double amount, Date date, double balance) {
        this.reason = reason;
        this.amount = amount;
        this.date = date;
        this.balance = balance;
    }

    public String getReason() {
        return reason;
    }

    public void setReason(String reason) {
        this.reason = reason;
    }

    public double getAmount() {
        return amount;
    }

    public void setAmount(double amount) {
        this.amount = amount;
    }

    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    @Override
    public String toString() {
        return reason + "\t" + (amount>0?"+":"")+amount + "\t" + getFormatedDateString() + "\t"+balance;
    }

    private String getFormatedDateString() {
        //如果date是null
        if(this.date==null){
            return "";
        }
        // 转换 Date 为 LocalDateTime
        LocalDateTime localDateTime = this.date.toInstant()
                .atZone(ZoneId.systemDefault())
                .toLocalDateTime();
        // 定义格式
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
        // 格式化日期
        return localDateTime.format(formatter);
    }
}