Go语言学习篇04
家庭收支记账软件项目
-
项目开发流程介绍
-
项目需求说明
-
项目的界面
-
项目代码实现
- 实现基本功能（先使用面向过程，后面改成面向对象）
项目开发流程介绍
项目需求说明
- 模拟实现基于文本界面的《家庭记账软件》
- 该软件能够记录家庭的收入、支出，并能够打印收支明细表
- 项目采用分级菜单方式。主菜单如下：
----------家庭收支记账软件----------
1 收支明细
2 登记收入
3 登记支出
4 退出
请选择（1-4）：
项目代码实现
先面向过程。再面向对象
- 显示主菜单、并能正常退出
- 完成显示明细的功能
- 完成登记收入功能
- 完成登记支出功能
面向过程
package main
import (
"fmt"
"strings"
)
func main() {
//定义账户余额
var balance = 10000.0
//每次收支的金额
var money float64 = 0.0
//每次收支的说明
var note string = ""
//详情
//当有收支，只需要进行details进行拼接就行
var details string = "收支\t账户金额\t收支金额\t说明"
//是否退出软件
var exit string
//是否进行收支,默认未收支
var flag bool = false
//显示主菜单
var selected int
flag01:
for {
fmt.Println("\n----------家庭收支记账软件----------")
fmt.Println("\n 1 收支明细")
fmt.Println(" 2 登记收入")
fmt.Println(" 3 登记支出")
fmt.Println(" 4 退 出")
fmt.Print("\n请选择(1-4)：")
fmt.Scanln(&selected)
switch selected {
case 1:
fmt.Println("----------当前收支明细记录----------")
if !flag {
fmt.Println("当前没有任何收支...")
break
}
fmt.Println(details)
case 2:
fmt.Print("本次收入金额:")
fmt.Scanln(&money)
fmt.Print("本次收入说明：")
fmt.Scanln(¬e)
balance += money
//将收入情况拼接到details中
details += fmt.Sprintf("\n收入\t%v\t%v\t%v", balance, money, note)
flag = true
case 3:
flag02:
fmt.Printf("总额度%v\n", balance)
fmt.Print("本次支出金额:")
fmt.Scanln(&money)
if money > balance {
fmt.Println("你的余额不足...")
flag04:
fmt.Print("是否重新输入支出金额?(y/n):")
fmt.Scanln(&exit)
if strings.EqualFold(exit, "y") {
//重新输入金额
goto flag02
} else if strings.EqualFold(exit, "n") {
//退出switch语句
break
} else {
fmt.Println("你的输入有误...")
//重新选项
goto flag04
}
flag = true
}
fmt.Print("本次支出说明：")
fmt.Scanln(¬e)
balance-= money
//将收入情况拼接到details中
details += fmt.Sprintf("\n支出\t%v\t%v\t%v", balance, money, note)
case 4:
flag03:
fmt.Print("你确定要退出吗？(y/n):")
fmt.Scanln(&exit)
if strings.EqualFold(exit, "y") {
//退出for循环
break flag01
}else if strings.EqualFold(exit, "n") {
//退出switch
break
} else {
fmt.Println("你的输入有误...")
//重新输入
goto flag03
}
default:
fmt.Println("你的输入有误...")
}
}
fmt.Println("已退出")
}
面向对象
- 思路
- 将记账软件的功能，封装到结构体中，通过调用结构体的方法来实现软件
utils代码
package utils
import (
"fmt"
"strings"
)
type familyAccount struct {
//是否退出软件，控制for循环
loop bool
//是否进行收支,默认未收支
flag bool
//定义账户余额
balance float64
//每次收支的金额
money float64
//每次收支的说明
note string
//收支详情
details string
//用户输入的选项
selected string
}
//编写一个构造方法---工厂模式
func NewFamilyAccount() *familyAccount {
return &familyAccount{
loop: true,
flag: false,
balance: 10000.0,
money: 0,
note: "",
details: "收支\t账户金额\t收支金额\t说明",
selected: "",
}
}
//给该结构体绑定相应的方法
//1、显示主菜单
func (family *familyAccount) MainMenu() {
for {
//清除上一次的记录，防止重复操作
family.familyClear()
fmt.Println("\n----------家庭收支记账软件----------")
fmt.Println("\n 1 收支明细")
fmt.Println(" 2 登记收入")
fmt.Println(" 3 登记支出")
fmt.Println(" 4 退 出")
fmt.Print("\n请选择(1-4)：")
fmt.Scanln(&family.selected)
switch family.selected {
case "1":
family.ShowDetails()
case "2":
family.Income()
case "3":
family.Expenditure()
case "4":
family.ExitSoftware()
default:
fmt.Println("你的输入有误...")
}
//退出for循环
if !family.loop {
break
}
}
}
//2、显示收支明细
func (family *familyAccount) ShowDetails() {
fmt.Println("----------当前收支明细记录----------")
if family.flag {
fmt.Println(family.details)
} else {
fmt.Println("当前没有任何收支...")
}
}
//3、登记收入
func (family *familyAccount) Income() {
fmt.Print("本次收入金额:")
fmt.Scanln(&family.money)
fmt.Print("本次收入说明：")
fmt.Scanln(&family.note)
//总金额
family.balance += family.money
//将收入拼接到details中
family.details += fmt.Sprintf("\n收入\t%v\t%v\t%v", family.balance, family.money, family.note)
//产生收支明细
family.flag = true
}
//4、登记支出
func (family *familyAccount) Expenditure() {
//显示可用总额度
fmt.Printf("总额度%v\n", family.balance)
fmt.Print("本次支出金额:")
fmt.Scanln(&family.money)
if family.money > family.balance {
fmt.Println("你的余额不足...")
return
}
fmt.Print("本次支出说明：")
fmt.Scanln(&family.note)
//计算得到支出后的总额度
family.balance-= family.money
//将收入拼接到details中
family.details += fmt.Sprintf("\n支出\t%v\t%v\t%v", family.balance, family.money, family.note)
//产生了收支明细
family.flag = true
}
//5、退出
func (family *familyAccount) ExitSoftware() {
var choice string
for {
fmt.Print("你确定要退出吗？(y/n):")
fmt.Scanln(&choice)
if strings.EqualFold(choice, "y") || strings.EqualFold(choice, "n") {
break
}
fmt.Println("你的输入有误...")
}
//判断客户是否选择Y进行退出
if strings.EqualFold(choice, "y") {
//表示退出
family.loop = false
}
}
//6、清除上一次操作记录
func (family *familyAccount) familyClear() {
family.selected = ""
family.money = 0.0
family.note = ""
}
main代码
package main
import (
"familyAccount/utils"
"fmt"
)
type User struct{
username string
password string
}
func (user *User) Login() {
if user.username == "carter" && user.password == "1122"{
var familyAccount = utils.NewFamilyAccount()
familyAccount.MainMenu()
fmt.Println("已成功退出")
} else {
fmt.Println("用户名或密码不正确!!!")
}
}
func main() {
var user User
fmt.Print("请输入用户名:")
fmt.Scanln(&user.username)
fmt.Print("请输入密码:")
fmt.Scanln(&user.password)
(&user).Login()
}
结果
----------家庭收支记账软件----------
1 收支明细
2 登记收入
3 登记支出
4 退 出
请选择(1-4)：2
本次收入金额:6000
本次收入说明：工资
----------家庭收支记账软件----------
1 收支明细
2 登记收入
3 登记支出
4 退 出
请选择(1-4)：1
----------当前收支明细记录----------
收支 账户金额 收支金额 说明
收入 16000 6000 工资
----------家庭收支记账软件----------
1 收支明细
2 登记收入
3 登记支出
4 退 出
请选择(1-4)：3
总额度16000
本次支出金额:60
本次支出说明：看电影
----------家庭收支记账软件----------
1 收支明细
2 登记收入
3 登记支出
4 退 出
请选择(1-4)：1
----------当前收支明细记录----------
收支 账户金额 收支金额 说明
收入 16000 6000 工资
支出 15940 60 看电影
----------家庭收支记账软件----------
1 收支明细
2 登记收入
3 登记支出
4 退 出
请选择(1-4)：4
你确定要退出吗？(y/n):
客户信息管理系统项目
项目需求分析
1）模拟实现基于文本界面的《客户端信息管理软件》
2）能够实现对客户对象的插入、修改和删除（用切片实现），并能够打印客户明细表
程序框架图
项目结构
view
package main
import (
"customterManage/model"
"customterManage/service"
"fmt"
"strings"
)
type customerView struct {
//接收客户输入
key string
//是否循环主菜单
loop bool
//customerService字段
customerService *service.CustomerService
}
//显示主菜单
func (view *customerView) MainMenu() {
for {
//清除
view.CustomerClear()
fmt.Println("\n----------客户信息管理软件----------")
fmt.Println("\n 1 添加客户")
fmt.Println(" 2 修改客户")
fmt.Println(" 3 删除客户")
fmt.Println(" 4 客户列表")
fmt.Println(" 5 退出")
fmt.Print("\n请输入(1-5):")
fmt.Scanln(&view.key)
switch view.key {
case "1":
view.add()
case "2":
view.list()
view.update()
case "3":
view.list()
view.delete()
case "4":
view.list()
case "5":
view.Exit()
default:
fmt.Println("你的输入有误...")
}
//判断是否退出
if !view.loop {
break
}
}
}
//更新用户
func (view *customerView) update() {
var id int = -1
fmt.Print("\n输入你需要修改的用户编号:")
fmt.Scanln(&id)
if id == -1 {
return
}
oldCustomer, index := view.customerService.FindCustomer(id)
if index == -1 && oldCustomer == nil {
fmt.Println("你需要修改的用户不存在...")
return
}
var name string = ""
var gender string = ""
var age int = 0
var phone string = ""
var email string = ""
fmt.Printf("姓名(%v)：", oldCustomer.Name)
fmt.Scanln(&name)
fmt.Printf("性别(%v)：", oldCustomer.Gender)
fmt.Scanln(&gender)
fmt.Printf("年龄(%v)：", oldCustomer.Age)
fmt.Scanln(&age)
fmt.Printf("电话(%v)：", oldCustomer.Phone)
fmt.Scanln(&phone)
fmt.Printf("邮箱(%v)：", oldCustomer.Email)
fmt.Scanln(&email)
//使用工厂模式
var newCustomer = model.NewCustomer(id, name, gender, age, phone, email)
flag := view.customerService.Update(index, &newCustomer)
if flag {
fmt.Println("修改成功...")
} else {
fmt.Println("修改失败...")
}
}
//删除客户
func (view *customerView) delete() {
var id int = -1
fmt.Print("\n请输入需删除的用户编号:")
fmt.Scanln(&id)
if id == -1 {
return //放弃删除操作
}
var choice string = ""
fmt.Print("是否删除？(y/n):")
for {
fmt.Scanln(&choice)
if strings.EqualFold(choice, "y") || strings.EqualFold(choice, "n") {
break
}
fmt.Print("输入有误，是否删除？(y/n):")
}
if strings.EqualFold(choice, "y") {
flag := view.customerService.Delete(id)
if flag {
fmt.Println("删除成功...")
} else {
fmt.Println("删除失败，客户id不存在...")
}
}
}
//增加客户
func (view *customerView) add() {
var name string = ""
var gender string = ""
var age int = 0
var phone string = ""
var email string = ""
fmt.Print("姓名：")
fmt.Scanln(&name)
fmt.Print("性别：")
fmt.Scanln(&gender)
fmt.Print("年龄：")
fmt.Scanln(&age)
fmt.Print("电话：")
fmt.Scanln(&phone)
fmt.Print("邮箱：")
fmt.Scanln(&email)
//使用工厂模式
var newCustomer = model.NewCustomerNoId(name, gender, age, phone, email)
flag := view.customerService.Add(newCustomer)
if flag {
fmt.Println("添加客户成功...")
} else {
fmt.Println("添加失败...")
}
}
//客户列表
func (view *customerView) list(){
customers := view.customerService.List()
fmt.Println("\n------------客户列表------------")
fmt.Println("编号\t姓名\t性别\t年龄\t电话\t邮箱")
for _, customer := range customers {
fmt.Println(&customer)
}
}
//退出功能
func (view *customerView) Exit() {
var choice string
fmt.Print("是否退出?(y/n):")
for {
fmt.Scanln(&choice)
if strings.EqualFold(choice, "y") || strings.EqualFold(choice, "n") {
break
}
fmt.Print("输入有误，是否退出?(y/n):")
}
//输入y表示退出
if strings.EqualFold(choice, "y") {
view.loop = false
}
}
//清除功能
func (view *customerView) CustomerClear() {
view.key = ""
}
func main() {
var view = customerView{
key: "",
loop: true,
}
view.customerService = service.NewCustomerService()
view.MainMenu()
}
service
package service
import (
"customterManage/model"
)
//完成对Customer的操作，增删改查
type CustomerService struct {
customers []model.Customer
//当前切片含有多少个客户,可以作为新客户的编号
customerNum int
}
//工厂模式
func NewCustomerService() *CustomerService {
var customerService *CustomerService = new(CustomerService)
customerService.customerNum = 1
var customer model.Customer = model.NewCustomer(1, "廖述幸", "男", 20, "15675288363", "2672439345@qq.com")
customerService.customers = append(customerService.customers, customer)
return customerService
}
//客户列表
func (customer *CustomerService) List() []model.Customer {
return (*customer).customers
}
//增加
func (customer *CustomerService) Add(newCustomer model.Customer) bool {
//分配Id规则
(*customer).customerNum++
newCustomer.Id = (*customer).customerNum
//切片添加元素
(*customer).customers = append((*customer).customers, newCustomer)
return true
}
//删除
func (customer *CustomerService) Delete(id int) bool {
index := customer.FindById(id)
if index == -1 {
return false
}
//删除切片对应下标
customer.customers = append(customer.customers[:index],customer.customers[index+1:]...)
return true
}
//修改
func (customer *CustomerService) Update(index int, newCustomer *model.Customer) bool {
(*customer).customers[index] = *newCustomer
return true
}
//查找切片下标
func (customer *CustomerService) FindById(id int) int {
//查询客户Id
for index, customer := range customer.customers {
if id == customer.Id {
//返回下标，进行删除操作
return index
}
}
//-1表示不存在
return -1
}
//查找用户
func (customer *CustomerService) FindCustomer(id int) (oldCustomer *model.Customer,index int) {
for index, customer := range (*customer).customers {
if customer.Id == id {
return &customer,index
}
}
return nil,-1
}
model
package model
import "fmt"
//定义声明一个Customer结构体，表示客户信息
type Customer struct{
Id int
Name string
Gender string
Age int
Phone string
Email string
}
//使用工厂实例
func NewCustomer(id int, name string, gender string,
age int, phone string, email string) Customer {
return Customer{
Id: id,
Name: name,
Gender: gender,
Age: age,
Phone: phone,
Email: email,
}
}
//不带Id的工厂模式
func NewCustomerNoId(name string, gender string,
age int, phone string, email string) Customer {
return Customer{
Name: name,
Gender: gender,
Age: age,
Phone: phone,
Email: email,
}
}
//用户信息格式化输出
func (customer *Customer) String() string {
return fmt.Sprintf("%v\t\t%v\t%v\t\t%v\t%v\t%v",
customer.Id, customer.Name, customer.Gender, customer.Age, customer.Phone, customer.Email)
}
结果
----------客户信息管理软件----------
1 添加客户
2 修改客户
3 删除客户
4 客户列表
5 退出
请输入(1-5):4
------------客户列表------------
编号 姓名 性别 年龄 电话 邮箱
1 廖述幸 男 20 15675288363 2672439345@qq.com
----------客户信息管理软件----------
1 添加客户
2 修改客户
3 删除客户
4 客户列表
5 退出
...
one: phone,
Email: email,
}
}
//不带Id的工厂模式
func NewCustomerNoId(name string, gender string,
age int, phone string, email string) Customer {
return Customer{
Name: name,
Gender: gender,
Age: age,
Phone: phone,
Email: email,
}
}
//用户信息格式化输出
func (customer *Customer) String() string {
return fmt.Sprintf("%v\t\t%v\t%v\t\t%v\t%v\t%v",
customer.Id, customer.Name, customer.Gender, customer.Age, customer.Phone, customer.Email)
}
**结果**
~~~go
----------客户信息管理软件----------
1 添加客户
2 修改客户
3 删除客户
4 客户列表
5 退出
请输入(1-5):4
------------客户列表------------
编号 姓名 性别 年龄 电话 邮箱
1 廖述幸 男 20 15675288363 2672439345@qq.com
----------客户信息管理软件----------
1 添加客户
2 修改客户
3 删除客户
4 客户列表
5 退出
...
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
