1. 项目开发流程
  2. 项目需求
  3. 项目界面
  4. 项目代码实现
    1. 先使用面向过程，后改为面向对象

image.png
项目金额预估 = 人员+时间+软硬件设备+buffer

项目需求

  1. 模拟实现基于文本界面的《家庭记账软件》
  2. 该软件能够记录家庭的收入、支出，并能够打印收支明细表
  3. 项目界面（类似于ATM机上的功能）

image.png
image.png

面向过程

  1. 先完成可以显示主菜单，并且可以退出
  2. 完成可以显示明细的功能
  3. 完成登记收入的功能
  4. 完成登记支出的功能

    代码

    ```go // 家庭收支记账软件 - 面向过程实现 package main

import ( “fmt” )

func main() { // 声明变量，接收用户输入菜单项 key := “” // 声明变量，控制是否退出for loop := true

  1. // 定义账户余额
  2. blance := 1000.0
  3. // 每次收支的金额
  4. money := 0.0
  5. //收支说明
  6. note := ""
  7. // 定义一个变量，表示是否存在收支记录
  8. flag := false
  9. // 收支详情，使用字符串记录
  10. // 当有收支记录的时候，只需要对 details 拼接即可
  11. details := "收支\t账户金额\t收支金额\t说明"
  13. // 显示主菜单
  14. for {
  15.     fmt.Println("***********************家庭收支记账软件***********************")
  16.     fmt.Println("                       1、收支明细")
  17.     fmt.Println("                       2、登记收入")
  18.     fmt.Println("                       3、登记支出")
  19.     fmt.Println("                       4、退出软件")
  20.     fmt.Print("请选择(1-4): ")
  21.     fmt.Scanln(&key)
  22.     switch key {
  23.     case "1":
  24.         if !flag {
  25.             fmt.Println("目前为止，你还没有收支记录，来一笔吧🎈")
  26.         } else {
  27.             fmt.Println("***********************当前收支明细记录***********************")
  28.             fmt.Println(details)
  29.         }
  30.     case "2":
  31.         fmt.Println("***********************登记收入***********************")
  32.         fmt.Println("本次收入金额: ")
  33.         fmt.Scanln(&money)
  34.         fmt.Println("本次收入说明: ")
  35.         fmt.Scanln(&note)
  36.         blance += money
  37.         details += fmt.Sprintf("\n收入\t%v\t\t%v\t\t%v", blance, money, note)
  38.         flag = true
  39.     case "3":
  40.         fmt.Println("***********************登记支出***********************")
  41.         fmt.Println("本次支出金额")
  42.         fmt.Scanln(&money)
  43.         if money > blance {
  44.             fmt.Println("余额不足啦")
  45.             break
  46.         }
  47.         blance -= money
  48.         fmt.Println("本次收入说明: ")
  49.         fmt.Scanln(&note)
  50.         details += fmt.Sprintf("\n支出\t%v\t\t%v\t\t%v", blance, money, note)
  51.         flag = true
  52.     case "4":
  53.         fmt.Println("你确定退出吗，请输入：Y(是)/N(否)")
  54.         choice := ""
  55.         for {
  56.             fmt.Scanln(&choice)
  57.             if choice == "Y" || choice == "N" {
  58.                 break
  59.             }
  60.             fmt.Println("你的输入有误，请重新输入：Y/N")
  61.         }
  62.         if choice == "Y" {
  63.             loop = false
  64.         }
  65.     }
  66.     if !loop {
  67.         break
  68.     }
  69.     fmt.Println()
  70.     fmt.Println()
  71. }
  72. fmt.Println("你退出了家庭记账软件🤞")

}

  1. <a name="nF1Ye"></a>
  2. # 面向过程修改成面向对象
  3. 抽象思维<br />封装-继承-多态
  4. <a name="qFYYh"></a>
  5. ## 思路分析
  7. 1. 把记账软件的功能，封装到一个结构体中，然后调用该结构的方法，来实现**记账**，**显示明细**。结构体的名字 **FamilyAccount**
  8. 2. 再通过在 **main** 方法中，创建结构体 **FamilyAccount 实例**，实现记账即可。
  9. 3. 代码不需要重写，只需要重新组织
  10. <a name="T3ziY"></a>
  11. ## 代码实现
  12. <a name="kL8ea"></a>
  13. ### familyAccount/utils/familyAccount.go
  14. ```go
  15. // 面向对象的方式实现 家庭记账软件
  16. // 封装、继承、多态
  17. package utils
  19. import (
  20.     "fmt"
  21. )
  23. type FamilyAccount struct {
  24.     // 声明必须的字段
  26.     // 声明字段，接收用户输入菜单项
  27.     key string
  28.     // 声明字段，控制是否退出for
  29.     loop bool
  31.     // 定义账户余额
  32.     blance float64
  33.     // 每次收支的金额
  34.     money float64
  35.     //收支说明
  36.     note string
  37.     // 定义一个字段，表示是否存在收支记录
  38.     flag bool
  39.     // 收支详情，使用字符串记录
  40.     // 当有收支记录的时候，只需要对 details 拼接即可
  41.     details string
  42.     // details := "收支\t账户金额\t收支金额\t说明"
  43. }
  45. // 编写一个工厂模式的构造函数，返回 FamilyAccount
  46. func NewFamilyAccount() *FamilyAccount {
  47.     // 给定初始值
  48.     return &FamilyAccount{
  49.         key:     "",
  50.         loop:    true,
  51.         blance:  1000.0,
  52.         money:   0.0,
  53.         note:    "",
  54.         flag:    false,
  55.         details: "收支\t账户金额\t收支金额\t说明",
  56.     }
  57. }
  59. // 将每个菜单的功能封装成一个方法
  60. // 明细
  61. func (account *FamilyAccount) ShowDetails() {
  62.     if !account.flag {
  63.         fmt.Println("目前为止，你还没有收支记录，来一笔吧🎈")
  64.     } else {
  65.         fmt.Println("***********************当前收支明细记录***********************")
  66.         fmt.Println(account.details)
  67.     }
  68. }
  70. // 登记收入方法
  71. func (account *FamilyAccount) Income() {
  72.     fmt.Println("***********************登记收入***********************")
  73.     fmt.Println("本次收入金额: ")
  74.     fmt.Scanln(&account.money)
  75.     fmt.Println("本次收入说明: ")
  76.     fmt.Scanln(&account.note)
  77.     account.blance += account.money
  78.     account.details += fmt.Sprintf("\n收入\t%v\t\t%v\t\t%v", account.blance, account.money, account.note)
  79.     account.flag = true
  80. }
  82. // 登记支出方法
  83. func (account *FamilyAccount) Pay() {
  84.     fmt.Println("***********************登记支出***********************")
  85.     fmt.Println("本次支出金额")
  86.     fmt.Scanln(&account.money)
  87.     if account.money > account.blance {
  88.         fmt.Println("余额不足啦")
  89.         // break
  90.     }
  91.     account.blance -= account.money
  92.     fmt.Println("本次收入说明: ")
  93.     fmt.Scanln(&account.note)
  94.     account.details += fmt.Sprintf("\n支出\t%v\t\t%v\t\t%v", account.blance, account.money, account.note)
  95.     account.flag = true
  96. }
  98. // 退出方法
  99. func (account *FamilyAccount) Exit() {
  100.     fmt.Println("你确定退出吗，请输入：Y(是)/N(否)")
  101.     choice := ""
  102.     for {
  103.         fmt.Scanln(&choice)
  104.         if choice == "Y" || choice == "N" {
  105.             break
  106.         }
  107.         fmt.Println("你的输入有误，请重新输入：Y/N")
  108.     }
  109.     if choice == "Y" {
  110.         account.loop = false
  111.     }
  112. }
  114. // 给 FamilyAccount 结构体绑定方法
  115. // 显示主菜单
  116. func (account *FamilyAccount) MainMenu() {
  117.     for {
  118.         fmt.Println("***********************家庭收支记账软件***********************")
  119.         fmt.Println("                       1、收支明细")
  120.         fmt.Println("                       2、登记收入")
  121.         fmt.Println("                       3、登记支出")
  122.         fmt.Println("                       4、退出软件")
  123.         fmt.Print("请选择(1-4): ")
  124.         fmt.Scanln(&account.key)
  125.         switch account.key {
  126.         case "1":
  127.             account.ShowDetails()
  128.         case "2":
  129.             account.Income()
  130.         case "3":
  131.             account.Pay()
  132.         case "4":
  133.             account.Exit()
  134.         }
  135.         if !account.loop {
  136.             break
  137.         }
  138.         fmt.Println()
  139.         fmt.Println()
  140.     }
  141.     fmt.Println("你退出了家庭记账软件🤞")
  142. }

familyAccount/main/main.go

  1. // 面向对象方式完成调用
  2. package main
  4. import (
  5.     _ "fmt"
  6.     "go_code/familyAccount/utils"
  7. )
  9. func main() {
  10.     // account := utils.NewFamilyAccount()
  11.     // fmt.Println("account = ", *account)
  12.     //  true 1000 0  false 收支    账户金额        收支金额        说明}
  13.     utils.NewFamilyAccount().MainMenu()
  14. }