家庭收支记账软件项目

项目开发流程说明

  1. 项目开发流程

    • 需求分析 -> 设计阶段 -> 实现阶段 -> 测试阶段 -> 项目实施 -> 维护阶段

      项目需求说明

  2. 模拟实现基于文本界面的《家庭记账软件》

  3. 该软件能够记录家庭的收入、支出，并能够打印收支明细表。

    项目的界面

  4. 项目采用分级菜单方式。

    项目代码实现

    实现基本功能(先使用面向过程，后面改成面向对象)

    编写文件 TestMyAccount.go 完成基本功能

  5. 功能一：先完成可以显示主菜单，并且可以退出。

    • 思路分析：根据给出界面完成主菜单的显示，当用户输入 4 时，就退出程序。 ```go package main

import “fmt”

func main() { //声明一个变量，保存接收用户输入的选项 key := “” //声明一个变量，控制是否退出 for loop := true //显示主菜单 for { fmt.Println(“——————家庭收支记账软件——————“) fmt.Println(“ 1 收支明细”) fmt.Println(“ 2 登记收入”) fmt.Println(“ 3 登记支出”) fmt.Println(“ 4 退出软件”) fmt.Print(“请选择(1-4): “)

  1.     fmt.Scanln(&key)
  3.     switch key {
  4.     case "1":
  5.         fmt.Println("------------当前收支明细记录------------")
  6.     case "2":
  7.         fmt.Println("登记收入..")
  8.     case "3":
  9.         fmt.Println("登记支出..")
  10.     case "4":
  11.         loop = false
  12.     default:
  13.         fmt.Println("请输入正确选项..")
  14.     }
  16.     if !loop {
  17.         break
  18.     }
  20. }
  22. fmt.Println("你退出家庭记账软件的使用..")

}

  2. 2. 功能二：完成可以显示明细和登记收入的功能 
  3.    - 思路分析 
  4.       - 因为需要显示明细，我们定义一个变量 details string 来记录
  5.       - 还需要定义变量来记录余额(balance)、每次收支金额(money)，每次收支的说明(note)
  6. ```go
  7. package main
  9. import "fmt"
  12. func main() {
  13.     //声明一个变量，保存接收用户输入的选项
  14.     key := ""
  15.     //声明一个变量，控制是否退出 for
  16.     loop := true
  17.     //定义账户的余额
  18.     balance := 10000.0
  19.     //每次收支的金额
  20.     money := 0.0
  21.     //每次收支的说明
  22.     note := ""
  23.     //收支的详情使用字符串来记录
  24.     //当有收支时，只需要对 details 拼接处理即可
  25.     details := "收支\t\t账户余额\t\t收支金额\t\t说明"
  26.     //显示主菜单
  27.     for {
  28.         fmt.Println("\n------------家庭收支记账软件------------")
  29.         fmt.Println("              1 收支明细")
  30.         fmt.Println("              2 登记收入")
  31.         fmt.Println("              3 登记支出")
  32.         fmt.Println("              4 退出软件")
  33.         fmt.Print("请选择(1-4): ")
  35.         fmt.Scanln(&key)
  37.         switch key {
  38.         case "1":
  39.             fmt.Println("------------当前收支明细记录------------")
  40.             fmt.Println(details)
  41.         case "2":
  42.             fmt.Println("登记收入..")
  43.             fmt.Println("本次收入金额：")
  44.             fmt.Scanln(&money)
  45.             balance += money //修改账户余额
  46.             fmt.Println("本次收入说明：")
  47.             fmt.Scanln(&note)
  48.             //将这个收入情况，拼接到 details 变量
  49.             details += fmt.Sprintf("\n收入\t\t%v\t\t%v\t\t%v", balance, money, note)
  50.         case "3":
  51.             fmt.Println("登记支出..")
  52.             fmt.Println("本次收入金额：")
  54.         case "4":
  55.             loop = false
  56.         default:
  57.             fmt.Println("请输入正确选项..")
  58.         }
  60.         if !loop {
  61.             break
  62.         }
  64.     }
  66.     fmt.Println("你退出家庭记账软件的使用..")
  67. }
  1. 功能三：完成了等级支出的功能
    • 思路分析：
      • 登记支出和登记收入的功能类似，做一些修改即可。 ```go package main

import “fmt”

func main() { //声明一个变量，保存接收用户输入的选项 key := “” //声明一个变量，控制是否退出 for loop := true //定义账户的余额 balance := 10000.0 //每次收支的金额 money := 0.0 //每次收支的说明 note := “” //收支的详情使用字符串来记录 //当有收支时，只需要对 details 拼接处理即可 details := “收支\t\t账户余额\t\t收支金额\t\t说明” //显示主菜单 for { fmt.Println(“\n——————家庭收支记账软件——————“) fmt.Println(“ 1 收支明细”) fmt.Println(“ 2 登记收入”) fmt.Println(“ 3 登记支出”) fmt.Println(“ 4 退出软件”) fmt.Print(“请选择(1-4): “)

  1.     fmt.Scanln(&key)
  3.     switch key {
  4.     case "1":
  5.         fmt.Println("------------当前收支明细记录------------")
  6.         fmt.Println(details)
  7.     case "2":
  8.         fmt.Println("登记收入..")
  9.         fmt.Println("本次收入金额：")
  10.         fmt.Scanln(&money)
  11.         balance += money //修改账户余额
  12.         fmt.Println("本次收入说明：")
  13.         fmt.Scanln(&note)
  14.         //将这个收入情况，拼接到 details 变量
  15.         details += fmt.Sprintf("\n收入\t\t%v\t\t%v\t\t%v", balance, money, note)
  16.     case "3":
  17.         fmt.Println("登记支出..")
  18.         fmt.Println("本次支出金额：")
  19.         fmt.Scanln(&money)
  20.         //这里需要做必要的判断
  21.         if money > balance {
  22.             fmt.Println("余额不足..")
  23.             break
  24.         } else {
  25.             balance -= money
  26.         }
  27.         fmt.Println("本次支出说明：")
  28.         fmt.Scanln(&note)
  29.         //将这个支出情况，拼接到 details 变量
  30.         details += fmt.Sprintf("\n支出\t\t%v\t\t%v\t\t%v", balance, money, note)
  33.     case "4":
  34.         loop = false
  35.     default:
  36.         fmt.Println("请输入正确选项..")
  37.     }
  39.     if !loop {
  40.         break
  41.     }
  43. }
  45. fmt.Println("你退出家庭记账软件的使用..")

}

  1. <a name="81a8c974"></a>
  2. #### 项目代码实现改进
  4. 1. 用户输入 4 退出时，给出提示：你确定要退出吗？y/n，必须输入正确的y/n，否则循环输入指令，直到输入 y 或者 n。
  5. ```go
  6. package main
  8. import "fmt"
  11. func main() {
  12.     //声明一个变量，保存接收用户输入的选项
  13.     key := ""
  14.     //声明一个变量，控制是否退出 for
  15.     loop := true
  16.     //定义账户的余额
  17.     balance := 10000.0
  18.     //每次收支的金额
  19.     money := 0.0
  20.     //每次收支的说明
  21.     note := ""
  22.     //收支的详情使用字符串来记录
  23.     //当有收支时，只需要对 details 拼接处理即可
  24.     details := "收支\t\t账户余额\t\t收支金额\t\t说明"
  25.     //显示主菜单
  26.     for {
  27.         fmt.Println("\n------------家庭收支记账软件------------")
  28.         fmt.Println("              1 收支明细")
  29.         fmt.Println("              2 登记收入")
  30.         fmt.Println("              3 登记支出")
  31.         fmt.Println("              4 退出软件")
  32.         fmt.Print("请选择(1-4): ")
  34.         fmt.Scanln(&key)
  36.         switch key {
  37.         case "1":
  38.             fmt.Println("------------当前收支明细记录------------")
  39.             fmt.Println(details)
  40.         case "2":
  41.             fmt.Println("登记收入..")
  42.             fmt.Println("本次收入金额：")
  43.             fmt.Scanln(&money)
  44.             balance += money //修改账户余额
  45.             fmt.Println("本次收入说明：")
  46.             fmt.Scanln(&note)
  47.             //将这个收入情况，拼接到 details 变量
  48.             details += fmt.Sprintf("\n收入\t\t%v\t\t%v\t\t%v", balance, money, note)
  49.         case "3":
  50.             fmt.Println("登记支出..")
  51.             fmt.Println("本次支出金额：")
  52.             fmt.Scanln(&money)
  53.             //这里需要做必要的判断
  54.             if money > balance {
  55.                 fmt.Println("余额不足..")
  56.                 break
  57.             } else {
  58.                 balance -= money
  59.             }
  60.             fmt.Println("本次支出说明：")
  61.             fmt.Scanln(&note)
  62.             //将这个支出情况，拼接到 details 变量
  63.             details += fmt.Sprintf("\n支出\t\t%v\t\t%v\t\t%v", balance, money, note)
  66.         case "4":
  67.             fmt.Println("你确定要退出吗？y/n")
  68.             choice := ""
  69.             for {
  70.                 fmt.Scanln(&choice)
  71.                 if choice == "y" || choice == "n" {
  72.                     break
  73.                 }
  74.                 fmt.Println("你的输入有误，请重新输入 y/n")
  75.             }
  76.             if choice == "y" {
  77.                 loop = false
  78.             }
  80.         default:
  81.             fmt.Println("请输入正确选项..")
  82.         }
  84.         if !loop {
  85.             break
  86.         }
  88.     }
  90.     fmt.Println("你退出家庭记账软件的使用..")
  91. }
  1. 当没有任何收支明细时，提示：当前没有收支明细…来一笔吧！ ```go package main

import “fmt”

func main() { //声明一个变量，保存接收用户输入的选项 key := “” //声明一个变量，控制是否退出 for loop := true //定义账户的余额 balance := 10000.0 //每次收支的金额 money := 0.0 //每次收支的说明 note := “” //收支的详情使用字符串来记录 //当有收支时，只需要对 details 拼接处理即可 details := “收支\t\t账户余额\t\t收支金额\t\t说明” //定义一个变量，记录是否有收支行为 flags := false //显示主菜单 for { fmt.Println(“\n——————家庭收支记账软件——————“) fmt.Println(“ 1 收支明细”) fmt.Println(“ 2 登记收入”) fmt.Println(“ 3 登记支出”) fmt.Println(“ 4 退出软件”) fmt.Print(“请选择(1-4): “)

  1.     fmt.Scanln(&key)
  3.     switch key {
  4.     case "1":
  5.         fmt.Println("------------当前收支明细记录------------")
  6.         if flags {
  7.             fmt.Println(details)
  8.         } else {
  9.             fmt.Println("当前没有收支明细...来一笔吧！")
  10.         }
  12.     case "2":
  13.         fmt.Println("本次收入金额：")
  14.         fmt.Scanln(&money)
  15.         balance += money //修改账户余额
  16.         fmt.Println("本次收入说明：")
  17.         fmt.Scanln(&note)
  18.         //将这个收入情况，拼接到 details 变量
  19.         details += fmt.Sprintf("\n收入\t\t%v\t\t%v\t\t%v", balance, money, note)
  20.         flags = true
  21.     case "3":
  22.         fmt.Println("本次支出金额：")
  23.         fmt.Scanln(&money)
  24.         //这里需要做必要的判断
  25.         if money > balance {
  26.             fmt.Println("余额不足..")
  27.             break
  28.         } else {
  29.             balance -= money
  30.         }
  31.         fmt.Println("本次支出说明：")
  32.         fmt.Scanln(&note)
  33.         //将这个支出情况，拼接到 details 变量
  34.         details += fmt.Sprintf("\n支出\t\t%v\t\t%v\t\t%v", balance, money, note)
  35.         flags = true
  37.     case "4":
  38.         fmt.Println("你确定要退出吗？y/n")
  39.         choice := ""
  40.         for {
  41.             fmt.Scanln(&choice)
  42.             if choice == "y" || choice == "n" {
  43.                 break
  44.             }
  45.             fmt.Println("你的输入有误，请重新输入 y/n")
  46.         }
  47.         if choice == "y" {
  48.             loop = false
  49.         }
  51.     default:
  52.         fmt.Println("请输入正确选项..")
  53.     }
  55.     if !loop {
  56.         break
  57.     }
  59. }
  61. fmt.Println("你退出家庭记账软件的使用..")

}

  2. 3. 在支出时，判断余额是否足够，并给出相应的提示。
  3. ```go
  4. package main
  6. import "fmt"
  9. func main() {
  10.     //声明一个变量，保存接收用户输入的选项
  11.     key := ""
  12.     //声明一个变量，控制是否退出 for
  13.     loop := true
  14.     //定义账户的余额
  15.     balance := 10000.0
  16.     //每次收支的金额
  17.     money := 0.0
  18.     //每次收支的说明
  19.     note := ""
  20.     //收支的详情使用字符串来记录
  21.     //当有收支时，只需要对 details 拼接处理即可
  22.     details := "收支\t\t账户余额\t\t收支金额\t\t说明"
  23.     //定义一个变量，记录是否有收支行为
  24.     flags := false
  25.     //显示主菜单
  26.     for {
  27.         fmt.Println("\n------------家庭收支记账软件------------")
  28.         fmt.Println("              1 收支明细")
  29.         fmt.Println("              2 登记收入")
  30.         fmt.Println("              3 登记支出")
  31.         fmt.Println("              4 退出软件")
  32.         fmt.Print("请选择(1-4): ")
  34.         fmt.Scanln(&key)
  36.         switch key {
  37.         case "1":
  38.             fmt.Println("------------当前收支明细记录------------")
  39.             if flags {
  40.                 fmt.Println(details)
  41.             } else {
  42.                 fmt.Println("当前没有收支明细...来一笔吧！")
  43.             }
  45.         case "2":
  46.             fmt.Println("本次收入金额：")
  47.             fmt.Scanln(&money)
  48.             balance += money //修改账户余额
  49.             fmt.Println("本次收入说明：")
  50.             fmt.Scanln(&note)
  51.             //将这个收入情况，拼接到 details 变量
  52.             details += fmt.Sprintf("\n收入\t\t%v\t\t%v\t\t%v", balance, money, note)
  53.             flags = true
  54.         case "3":
  55.             fmt.Println("本次支出金额：")
  56.             fmt.Scanln(&money)
  57.             //这里需要做必要的判断
  58.             if money > balance {
  59.                 fmt.Println("余额不足..")
  60.                 break
  61.             } else {
  62.                 balance -= money
  63.             }
  64.             fmt.Println("本次支出说明：")
  65.             fmt.Scanln(&note)
  66.             //将这个支出情况，拼接到 details 变量
  67.             details += fmt.Sprintf("\n支出\t\t%v\t\t%v\t\t%v", balance, money, note)
  68.             flags = true
  70.         case "4":
  71.             fmt.Println("你确定要退出吗？y/n")
  72.             choice := ""
  73.             for {
  74.                 fmt.Scanln(&choice)
  75.                 if choice == "y" || choice == "n" {
  76.                     break
  77.                 }
  78.                 fmt.Println("你的输入有误，请重新输入 y/n")
  79.             }
  80.             if choice == "y" {
  81.                 loop = false
  82.             }
  84.         default:
  85.             fmt.Println("请输入正确选项..")
  86.         }
  88.         if !loop {
  89.             break
  90.         }
  92.     }
  94.     fmt.Println("你退出家庭记账软件的使用..")
  95. }
  1. 将面向过程的代码修改成面向对象的方法，编写 myFamilyAccount.go，并使用 testMyFamilyAccount.go 去完成测试。
    • 思路分析：
      • 把记账软件的功能，封装到一个结构体中，然后调用该结构体的方法，来实现记账，显示明细。结构体的名字：FamilyAccount
      • 在通过在 main 方法中，创建一个结构体 FamilyAccount 实例，实现记账即可。
      • 代码并不需要重写，只需要重新组织即可。 ```go //-utils包：familyAccount.go package utils

import “fmt”

type FamilyAccount struct { //声明必要的字段 //声明一个字段，保存接收用户输入的选项 key string //声明一个字段，控制是否退出 for loop bool //定义账户的余额 balance float64 //每次收支的金额 money float64 //每次收支的说明 note string //定义一个字段，记录是否有收支行为 flag bool //收支的详情使用字符串来记录 //当有收支时，只需要对 details 拼接处理即可 details string }

//编写一个工厂模式的构造方法，返回一个 FamilyAccount 实例 func NewFamilyAccount() FamilyAccount { return &FamilyAccount{ key : “”, loop : true, balance : 10000.0, money : 0.0, note : “”, flag : false, details : “收支\t\t账户余额\t\t收支金额\t\t说明”,

  1. }

}

//给该结构体绑定相应的方法 //将显示明细写成一个方法 func (this *FamilyAccount) showDetails() { fmt.Println(“——————当前收支明细记录——————“) if this.flag { fmt.Println(this.details) } else { fmt.Println(“当前没有收支明细…来一笔吧！”) } }

//给该结构体绑定相应的方法 //将登记收入写成一个方法 func (this *FamilyAccount) income() { fmt.Println(“本次收入金额：”) fmt.Scanln(&this.money) this.balance += this.money //修改账户余额 fmt.Println(“本次收入说明：”) fmt.Scanln(&this.note) //将这个收入情况，拼接到 details 变量 this.details += fmt.Sprintf(“\n收入\t\t%v\t\t%v\t\t%v”, this.balance, this.money, this.note) this.flag = true }

//给该结构体绑定相应的方法 //将登记支出写成一个方法 func (this *FamilyAccount) pay() { fmt.Println(“本次支出金额：”) fmt.Scanln(&this.money) //这里需要做必要的判断 if this.money > this.balance { fmt.Println(“余额不足..”) //break } else { this.balance -= this.money } fmt.Println(“本次支出说明：”) fmt.Scanln(&this.note) //将这个支出情况，拼接到 details 变量 this.details += fmt.Sprintf(“\n支出\t\t%v\t\t%v\t\t%v”, this.balance, this.money, this.note) this.flag = true }

//给该结构体绑定相应的方法 //将退出系统写成一个方法 func (this *FamilyAccount) exit() { fmt.Println(“你确定要退出吗？y/n”) choice := “” for { fmt.Scanln(&choice) if choice == “y” || choice == “n” { break } fmt.Println(“你的输入有误，请重新输入 y/n”) } if choice == “y” { this.loop = false } }

//给该结构体绑定相应的方法 //显示主菜单 func (this *FamilyAccount) MainMenu() { for { fmt.Println(“\n——————家庭收支记账软件——————“) fmt.Println(“ 1 收支明细”) fmt.Println(“ 2 登记收入”) fmt.Println(“ 3 登记支出”) fmt.Println(“ 4 退出软件”) fmt.Print(“请选择(1-4): “)

  1.     fmt.Scanln(&this.key)
  3.     switch this.key {
  4.     case "1":
  5.         this.showDetails()
  6.     case "2":
  7.         this.income()
  8.     case "3":
  9.         this.pay()
  10.     case "4":
  11.         this.exit()
  12.     default:
  13.         fmt.Println("请输入正确选项..")
  14.     }
  16.     if !this.loop {
  17.         break
  18.     }
  20. }
  21. fmt.Println("你退出家庭记账软件的使用..")

}

  2. ```go
  3. //-main包-main.go
  4. package main
  6. import (
  7.     "GoProject/src/go_code/chapter12/project_case_02/utils"
  8.     "fmt"
  9. )
  11. func main() {
  12.     fmt.Println("这个是面向对象的方式完成~")
  13.     utils.NewFamilyAccount().MainMenu() //思路清晰
  14. }

课程来源