Go語言中沒有類的概念,也不支持「類」的繼承等面向對象的概念。
Go語言中經過結構體的內嵌再配合接口,比面向對象具備更高的擴展性和靈活性。
1.類型別名和自定義類型
1.1自定義類型
在Go語言中有一些基本的數據類型,如string,整型,浮點型,布爾等數據類型,Go語言中可使用type關鍵字來定義自定義類型。
自定義類型是定義了一個全新的類型。咱們能夠基於內置的基本類型定義,也能夠經過struct定義。
//將MyInt定義爲int類型
type MyInt int
經過Type關鍵字的定義,MyInt就是一種新的類型,它具備int的特性。
1.2類型別名
類型別名是Go1.9版本添加的新功能。
類型別名規定:TypeAlias只是Type的別名,本質上TypeAlias與Type是同一個類型。就像咱們的英文名,乳名,但這些名字都指的是一我的。
type TypeAlias = type
咱們以前見過的rune和byte都是類型別名,他們的定義以下:
type byte = uint8
type rune = int32
1.3類型定義和類型別名的區別
類型別名與類型定義,表面上看只有一個等號的差別,咱們能夠經過下面的代碼來查看他們的區別。
package main
import "fmt"
type NewInt int
type MyInt = int
func main() {
var a NewInt
var b MyInt
fmt.Printf("type of a:%T\n",a)
fmt.Printf("type of b:%T\n",b)
}
結果:
type of a:main.NewInt
type of b:int
Process finished with exit code 0
結果顯示a的類型是main.NewInt,表示main包下定義的NewInt類型。
b類型是int。MyInt類型只會在代碼中存在,編譯完成時並不會有MyInt類型。
2.結構體
Go語言中的基本數據類型能夠表示一些事物的基本屬性,可是當咱們想表達一個事物的所有或部分屬性時,這時候基本數據類型就沒法知足需求了。
Go語言提供了一種自定義數據類型,能夠封裝多個基本數據類型,這種數據類型叫結構體(struct)。
咱們能夠經過struct來定義本身的類型了。
Go語言中經過struct來實現面向對象。
2.1結構體的定義
使用type和struct關鍵字來定義結構體,具體代碼格式以下:
type 類型名 struct {
字段名 字段類型
字段名 字段類型
…
}
其中:
類型名:標識自定義結構體的名稱,在同一個包內不能重複。
字段名:表示結構體字段名。結構體中的字段名必須惟一。
字段類型:表示結構體字段的具體類型。
舉個例子,咱們定義一個Person結構體,代碼以下:
type Person struct {
name string
city string
age int8
}
一樣類型的字段能夠卸載一行
type Person struct {
name,city string
age int8
}
這樣咱們就擁有了一個Person的自定義類型,它有name,city,age三個字段,分別表示姓名,城市和年齡。
這樣咱們就能使用Person結構體存儲人的信息了。
語言內置的數據類型是用來描述一個值得,結構體是用來描述一組值的。
好比一我的有名字,年齡和居住城市等,本質上是一種聚合型的數據類型。
2.2結構體實例化
只有當結構體實例化時,纔會真正的分配內存。即必須實例化後才能使用結構體的字段。
結構體自己也是一種類型,咱們能夠像聲明內置類型同樣使用var關鍵字聲明結構體類型。
var 結構體實例 結構體類型
2.2.1結構體基本實例化
經過"."來訪問結構體的字段,例如person1.name和person1.age
package main
import "fmt"
type Person struct {
name,city string
age int8
}
func main() {
var person1 Person
person1.name="vita"
person1.city="ShangHai"
person1.age=27
fmt.Printf("p1=%v\n",person1)
fmt.Printf("p1=%#v\n",person1)
}
結果:
p1={vita ShangHai 27}
p1=main.Person{name:"vita", city:"ShangHai", age:27}
Process finished with exit code 0
2.2.2匿名結構體
在定義一些臨時數據結構時,可使用匿名結構體。
package main
import "fmt"
func main() {
var person2 struct{name string;age int}
person2.name="vita"
person2.age=27
fmt.Printf("p1=%v\n",person2)
fmt.Printf("p1=%#v\n",person2)
}
結果:
p1={vita 27}
p1=struct { name string; age int }{name:"vita", age:27}
Process finished with exit code 0
2.2.3建立指針類型結構體
咱們還能夠經過new關鍵字對結構體進行實例化,獲得的是結構體的地址。
package main
import "fmt"
type Person struct {
name string
city string
age int
}
func main() {
var person3 = new(Person)
fmt.Printf("%T\n",person3)
fmt.Printf("p3=%#v\n",person3)
person3.name="vita"
person3.age=27
fmt.Printf("p3=%v\n",person3)
fmt.Printf("p3=%#v\n",person3)
}
結果:
*main.Person
p3=&main.Person{name:"", city:"", age:0}
p3=&{vita 27}
p3=&main.Person{name:"vita", city:"", age:27}
Process finished with exit code 0
從打印結果能夠看到,p3是一個結構體指針。
Go語言中支持對結構體指針直接使用"."訪問結構體成員。
2.2.4取結構體的地址實例化
使用&對結構體進行取地址操做至關於對該結構體進行了一次new實例化操做。
package main
import "fmt"
type Person struct {
name string
city string
age int
}
func main() {
var person4 = &Person{}
fmt.Printf("%T\n",person4)
fmt.Printf("p4=%#v\n",person4)
person4.name="vita"
person4.age=27
fmt.Printf("p4=%v\n",person4)
fmt.Printf("p4=%#v\n",person4)
}
結果:
*main.Person
p4=&main.Person{name:"", city:"", age:0}
p4=&{vita 27}
p4=&main.Person{name:"vita", city:"", age:27}
Process finished with exit code 0
person4.name="vita"其實在底層是(* person4).name="vita",這是Go語言幫咱們實現的語法糖。
2.3結構體初始化
沒有初始化的結構體,其成員變量都是對應類型的零值。
package main
import "fmt"
type Person struct {
name string
city string
age int
}
func main() {
var p1 Person
fmt.Printf("%T\n",p1)
fmt.Printf("p1=%v\n",p1)
fmt.Printf("p1=%#v\n",p1)
}
結果:
main.Person
p1={ 0}
p1=main.Person{name:"", city:"", age:0}
Process finished with exit code 0
2.3.1使用鍵值對初始化
使用鍵值對對結構體初始化時,鍵對應結構體的字段,值對應該字段的初始值。
package main
import "fmt"
type Person struct {
name string
city string
age int
}
func main() {
var p1 = Person{
name:"vita",
city:"ShangHai",
age:27,
}
fmt.Printf("%T\n",p1)
fmt.Printf("p1=%v\n",p1)
fmt.Printf("p1=%#v\n",p1)
}
結果:
main.Person
p1={vita ShangHai 27}
p1=main.Person{name:"vita", city:"ShangHai", age:27}
Process finished with exit code 0
也能夠對結構體指針進行鍵值對初始化
package main
import "fmt"
type Person struct {
name string
city string
age int
}
func main() {
var p1 = &Person{
name:"vita",
city:"ShangHai",
age:27,
}
fmt.Printf("%T\n",p1)
fmt.Printf("p1=%v\n",p1)
fmt.Printf("p1=%#v\n",p1)
}
結果:
*main.Person
p1=&{vita ShangHai 27}
p1=&main.Person{name:"vita", city:"ShangHai", age:27}
Process finished with exit code 0
某些字段沒有初始值的時候,該字段能夠不寫。沒有指定初始值的字段值就是該字段類型的零值。
package main
import "fmt"
type Person struct {
name string
city string
age int
}
func main() {
var p1 = &Person{
name:"vita",
}
fmt.Printf("%T\n",p1)
fmt.Printf("p1=%v\n",p1)
fmt.Printf("p1=%#v\n",p1)
}
結果:
*main.Person
p1=&{vita 0}
p1=&main.Person{name:"vita", city:"", age:0}
Process finished with exit code 0
2.3.3使用值的列表初始化
初始化結構體的時候能夠簡寫,也就是初始化的時候不寫鍵,直接寫值
package main
import "fmt"
type Person struct {
name string
city string
age int
}
func main() {
var p1 = &Person{
"vita",
"ShangHai",
27,
}
fmt.Printf("%T\n",p1)
fmt.Printf("p1=%v\n",p1)
fmt.Printf("p1=%#v\n",p1)
}
結果:
*main.Person
p1=&{vita ShangHai 27}
p1=&main.Person{name:"vita", city:"ShangHai", age:27}
Process finished with exit code 0
使用這種格式初始化時,須要注意:
1.必須初始化結構體的全部字段。
2.初始值的填充順序必須與字段在結構體中的聲明順序一致。
3.該方式不能和鍵值初始化方式混用。
2.4結構體佈局
結構體佔用一塊連續的內存。
package main
import "fmt"
type Person struct {
name string
city string
age int
}
func main() {
var p1 = &Person{
"vita",
"ShangHai",
27,
}
fmt.Printf("p1.name %p\n",&p1.name)
fmt.Printf("p1.city %p\n",&p1.city)
fmt.Printf("p1.age %p\n",&p1.age)
}
結果:
p1.name 0xc00005c360
p1.city 0xc00005c370
p1.age 0xc00005c380
Process finished with exit code 0
// 內存是以字節爲單位的十六進制數
// 1字節 = 8位 = 8bit
package main
import "fmt"
type test struct {
a int8
b int8
c int8
}
func main() {
var p1 = &test{
1,2,3,
}
fmt.Printf("p1.a %p\n",&p1.a)
fmt.Printf("p1.b %p\n",&p1.b)
fmt.Printf("p1.c %p\n",&p1.c)
}
結果:
p1.a 0xc000054080
p1.b 0xc000054081
p1.c 0xc000054082
Process finished with exit code 0
2.5構造函數
Go語言的結構體沒有構造函數,能夠本身實現。
下面的代碼就實現了一個Person的構造函數。由於struct是值類型,若是結構體比較複雜的話,值拷貝性能開銷會比較大,因此該構造函數返回的是結構體指針類型。
package main
import "fmt"
type Person struct {
name string
city string
age int
}
//構造函數
func newPerson(name,city string,age int) *Person {
return &Person{
name: name,
city: city,
age: age,
}
}
func main() {
//調用構造函數
p := newPerson("vita","ShangHai",27)
fmt.Printf("%#v",p)
}
結果:
&main.Person{name:"vita", city:"ShangHai", age:27}
Process finished with exit code 0
2.6方法和接收者
2.6.1方法和接收者
Go語言中的方法(method)是一種做用於特定類型變量的函數。這種特定類型變量叫作"接收者(Receiver)"。
接收者的概念就相似於其餘語言中的this或者self。
方法的定義格式以下:
func (接收者變量 接收者類型) 方法名(參數列表) (返回參數){
函數體
}
其中,
接收者變量:接收者中的參數變量名在命名的時候,官方建議使用接收者類型名的第一個小寫字母,而不是self,this之類的命名。
例如:Person類型的接收者變量應該命名爲p,Connector類型的接收者變量應該命名爲c等。
接收者類型:接收者類型和參數相似,能夠是指針類型和非指針類型。
方法名,參數列表,返回參數:具體格式與函數定義相同。
package main
import "fmt"
type Person struct {
name string
city string
age int
}
func newPerson(name,city string,age int) *Person {
return &Person{
name: name,
city: city,
age: age,
}
}
func (p Person) Dream() {
fmt.Printf("%s的夢想是實現本身的價值。",p.name)
}
func main() {
p := newPerson("vita","ShangHai",27)
p.Dream()
}
結果:
vita的夢想是實現本身的價值。
Process finished with exit code 0
方法與函數的區別是,函數不屬於任何類型,方法屬於特定的類型。
2.6.2指針類型的接收者
指針類型的接收者由一個結構體的指針組成,因爲指針的特性,調用方法時修改接收者指針的任意成員變量,在方法結束後,修改都是有效的。
這種方式接近於其餘語言中的this或者self。下面咱們爲Person添加一個SetAge方法,修改實例變量的年齡。
package main
import "fmt"
type Person struct {
name string
city string
age int
}
func newPerson(name,city string,age int) *Person {
return &Person{
name: name,
city: city,
age: age,
}
}
func (p Person) Dream() {
fmt.Printf("%s的夢想是實現本身的價值。",p.name)
}
//指針類型的接收者
func (p *Person) SetAge(newAge int) {
p.age=newAge
}
func main() {
p := newPerson("vita","ShangHai",27)
fmt.Println(p.age)
//修改年齡
p.SetAge(29)
fmt.Println(p.age)
}
結果:
27
29
Process finished with exit code 0
2.6.3值類型的接收者
當方法做用於值類型的接收者時,GO語言會在代碼運行時將接收者的值複製一份。
在值類型接收者的方法中,能夠獲取接收者的成員值,可是修改只是針對副本,沒法修改接收者變量自己。
package main
import "fmt"
type Person struct {
name string
city string
age int
}
func newPerson(name,city string,age int) *Person {
return &Person{
name: name,
city: city,
age: age,
}
}
func (p Person) Dream() {
fmt.Printf("%s的夢想是實現本身的價值。",p.name)
}
//值類型的接收者
func (p Person) SetAge(newAge int) {
p.age=newAge
}
func main() {
p := newPerson("vita","ShangHai",27)
fmt.Println(p.age)
//修改年齡
p.SetAge(29)
fmt.Println(p.age)
}
結果:
27
27
Process finished with exit code 0
2.6.4何時應該使用指針類型接收者
1.須要修改接收者中的值。
2.接收者是拷貝代價比較大的大對象。
3.保證一致性,若是有某個方法使用了指針接收者,那麼其餘的方法也應該使用指針接收者。
2.7任意類型添加方法
在GO語言中,接收者的類型能夠是任何類型,不只僅是結構體,任何類型均可以擁有方法。
舉個例子,咱們基於內置的int類型,使用type關鍵字能夠定義新的自定義類型,而後爲咱們的自定義類型添加方法。
package main
import "fmt"
type MyInt int
func (m MyInt) SayHello() {
fmt.Println("hello,我是一個Int")
}
func main() {
var m MyInt
m.SayHello()
m=100
fmt.Printf("%#v %T\n",m,m)
}
結果:
hello,我是一個Int
100 main.MyInt
Process finished with exit code 0
注意:
非本地類型不能定義方法,即不能給別的包的類型定義方法。
2.8結構體的匿名字段
結構體容許其成員字段在聲明時沒有字段名,只有字段類型,這種沒有名字的字段稱爲匿名字段。
匿名字段默認採用類型名做爲字段名,結構體要求字段名必須惟一,所以結構體中同種類型的匿名字段只能有一個。
package main
import "fmt"
type Person struct {
string
int
}
func main() {
p1:=Person{
"vita",
27,
}
fmt.Printf("%#v\n",p1)
fmt.Println(p1.string,p1.int)
}
結果:
main.Person{string:"vita", int:27}
vita 27
Process finished with exit code 0
2.9嵌套結構體
一個結構體中能夠嵌套另外一個結構體或結構體指針。
package main
import "fmt"
//地址結構體
type Address struct {
Province string
City string
}
//User結構體
type User struct {
Name string
Gender string
Address Address
}
func main() {
user1 := User{
Name:"vita",
Gender:"女",
Address:Address{
Province:"ShangHai",
City:"ShangHai",
},
}
fmt.Printf("user1=%#v\n",user1)
}
結果:
user1=main.User{Name:"vita", Gender:"女", Address:main.Address{Province:"ShangHai", City:"ShangHai"}}
Process finished with exit code 0
2.10嵌套匿名結構體
當訪問結構體成員時,會如今結構體中查找該字段,找不到就去匿名結構體中查找。
package main
import "fmt"
//地址結構體
type Address struct {
Province string
City string
}
//User結構體
type User struct {
Name string
Gender string
Address
}
func main() {
var user2 User
user2.Name = "vita"
user2.Gender = "女"
user2.Address.Province = "江蘇" //經過匿名結構體.字段名訪問
user2.City = "南京" //直接訪問匿名結構體的字段名
fmt.Printf("user1=%#v\n",user2)
}
結果:
user1=main.User{Name:"vita", Gender:"女", Address:main.Address{Province:"江蘇", City:"南京"}}
Process finished with exit code 0
2.11嵌套結構體的字段名衝突
嵌套結構體內部可能存在相同的字段名。這時候爲了不歧義,須要指定具體的內嵌結構體的字段
package main
//Address 地址結構體
type Address struct {
Province string
City string
CreateTime string
}
//Email 郵箱結構體
type Email struct {
Account string
CreateTime string
}
//User 用戶結構體
type User struct {
Name string
Gender string
Address
Email
}
func main() {
var user3 User
user3.Name = "沙河娜扎"
user3.Gender = "男"
// user3.CreateTime = "2019" //ambiguous selector user3.CreateTime
user3.Address.CreateTime = "2000" //指定Address結構體中的CreateTime
user3.Email.CreateTime = "2000" //指定Email結構體中的CreateTime
}
2.12結構體的"繼承"
Go語言中使用結構體也能夠實現其餘語言中面向對象的繼承。
//Animal 動物
type Animal struct {
name string
}
func (a *Animal) move() {
fmt.Printf("%s會動!\n", a.name)
}
//Dog 狗
type Dog struct {
Feet int8
*Animal //經過嵌套匿名結構體實現繼承
}
func (d *Dog) wang() {
fmt.Printf("%s會汪汪汪~\n", d.name)
}
func main() {
d1 := &Dog{
Feet: 4,
Animal: &Animal{ //注意嵌套的是結構體指針
name: "樂樂",
},
}
d1.wang() //樂樂會汪汪汪~
d1.move() //樂樂會動!
}
2.13結構體字段的可見性
結構體中字段大寫開頭表示可公開訪問,小寫表示私有(僅在定義當前結構體的包中可訪問)。
1.14結構體與JSON序列化
JSON數據是一些鍵值對數據,便於閱讀和編寫。
package main
import (
"encoding/json"
"fmt"
)
type Student struct {
ID int
Gender string
Name string
}
type Class struct {
Title string
Students []*Student
}
func main() {
c:=&Class{
Title: "101",
Students: make([]*Student,0,200),
}
for i:=0;i<10;i++{
stu := &Student{
ID: i,
Gender: "男",
Name: "張三",
}
c.Students = append(c.Students,stu)
}
//JSON序列化:結構體--》JSON格式的字符串
data,err := json.Marshal(c)
if err != nil{
fmt.Println("json marshal failed")
return
}
fmt.Printf("json:%s\n",data)
//JSON反序列化:JSON格式的字符串--》結構體
str := `{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"stu00"},{"ID":1,"Gender":"男","Name":"stu01"},{"ID":2,"Gender":"男","Name":"stu02"},{"ID":3,"Gender":"男","Name":"stu03"},{"ID":4,"Gender":"男","Name":"stu04"},{"ID":5,"Gender":"男","Name":"stu05"},{"ID":6,"Gender":"男","Name":"stu06"},{"ID":7,"Gender":"男","Name":"stu07"},{"ID":8,"Gender":"男","Name":"stu08"},{"ID":9,"Gender":"男","Name":"stu09"}]}`
c1 := &Class{}
err = json.Unmarshal([]byte(str),c1)
if err != nil{
fmt.Println("json unmarshal failed!")
return
}
fmt.Printf("%#v\n",c1)
}
結果:
json:{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"張三"},{"ID":1,"Gender":"男","Name":"張三"},{"ID":2,"Gender":"男","Name":"張三"},{"ID":3,"Gender":"男","Name":"張三"},{"ID":4,"Gender":"男","Name":"張三"},{"ID":5,"Gender":"男","Name":"張三"},{"ID":6,"Gender":"男","Name":"張三"},{"ID":7,"Gender":"男","Name":"張三"},{"ID":8,"Gender":"男","Name":"張三"},{"ID":9,"Gender":"男","Name":"張三"}]}
&main.Class{Title:"101", Students:[]*main.Student{(*main.Student)(0xc0000526f0), (*main.Student)(0xc000052720), (*main.Student)(0xc000052750), (*main.Student)(0xc000052780), (*main.Student)(0xc0000527e0), (*main.Student)(0xc000052810), (*main.Student)(0xc000052840), (*main.Student)(0xc000052870), (*main.Student)(0xc0000528a0), (*main.Student)(0xc0000528d0)}}
Process finished with exit code 0
2.15結構體標籤(Tag)
Tag是結構體的元信息,能夠在運行的時候經過反射的 機制讀取出來。
Tag在結構體字段的後方定義,由一對反引號包裹起來,具體格式以下:
`key1:"value1" key2:"value2"`
結構體標籤由一個或多個鍵值對組成。鍵和值使用冒號分隔,值用引號括起來。
鍵值對質檢使用一個空格分隔,
注意事項:
1.爲結構體編寫Tag時,必須嚴格遵照鍵值對的規則。
2.結構體標籤的解析代碼的容錯能力不好,一旦格式寫錯,編譯和運行時都不會提示任何錯誤,經過反射也沒法正確取值。
3.key和value之間是不能夠有空格的。
package main
import (
"encoding/json"
"fmt"
)
type Student struct {
ID int `json:"id"` //經過指定tag實現json序列化該字段時的key
Gender string //json序列化是默認使用字段名做爲key
name string //私有不能被json包訪問
}
func main() {
s1 := Student{
ID: 1,
Gender: "男",
name: "沙河娜扎",
}
data,err := json.Marshal(s1)
if err != nil{
fmt.Println("json marshal failed!")
return
}
fmt.Printf("json str:%s\n",data)
}
結果:
json str:{"id":1,"Gender":"男"}
Process finished with exit code 0
3.書籍的增刪改查
package main
import (
"fmt"
"os"
)
// 1. 打印菜單
// 2. 等待用戶輸入菜單選項
// 3. 添加書籍的函數
// 4. 修改書籍的函數
// 5. 展現書籍的函數
// 6. 退出 os.Exit(0)
type Book struct {
title string
author string
price float32
publish bool
}
var(
AllBooks []*Book
)
func showMenu() {
fmt.Println("1.展現全部書籍")
fmt.Println("2.添加書籍")
fmt.Println("3.修改書籍")
fmt.Println("4.刪除書籍")
fmt.Println("5.退出")
fmt.Println()
}
func showAllBook() {
fmt.Println("書籍信息以下:")
for _,value := range AllBooks{
fmt.Printf("title:%s author:%s price:%.2f publish:%v",value.title,value.author,value.price,value.publish)
}
fmt.Println()
}
func newBook(title,author string,price float32,publish bool) *Book {
return &Book{
title:title,
author:author,
price:price,
publish:publish,
}
}
func addBook() {
var (
title string
author string
price float32
publish bool
)
fmt.Println("輸入書籍的title(string),author(string),price(float32),publish(bool)信息")
fmt.Scanln(&title,&author,&price,&publish)
for _,value := range AllBooks{
if value.title == title{
fmt.Println("該書已經存在了!")
return
}
}
book := newBook(title,author,price,publish)
AllBooks = append(AllBooks,book)
}
func modifyBook() {
fmt.Println("輸入要修改的書籍信息")
var (
title string
author string
price float32
publish bool
)
fmt.Println("輸入書籍的title(string),author(string),price(float32),publish(bool)信息")
fmt.Scanln(&title,&author,&price,&publish)
for index,value := range AllBooks{
if value.title == title{
modifyBook := newBook(title,author,price,publish)
AllBooks[index] = modifyBook
fmt.Println("書籍信息修改爲功!")
return
}
}
fmt.Println("該書不存在,就不進行修改了!")
}
func delBook() {
var (
title string
)
fmt.Println("輸入要刪除的書籍名稱")
fmt.Scanln(&title)
for index,value := range AllBooks{
if value.title == title{
// 要刪除索引爲2的元素
AllBooks = append(AllBooks[:index], AllBooks[index+1:]...)
fmt.Println("書籍刪除成功!")
return
}
}
fmt.Println("該書不存在!")
}
func main() {
for{
showMenu()
var input int
fmt.Scanln(&input)
switch input {
case 1:
showAllBook()
case 2:
addBook()
case 3:
modifyBook()
case 4:
delBook()
case 5:
os.Exit(0)
}
}
}
結果:
1.展現全部書籍
2.添加書籍
3.修改書籍
4.刪除書籍
5.退出
1
書籍信息以下:
1.展現全部書籍
2.添加書籍
3.修改書籍
4.刪除書籍
5.退出
2
輸入書籍的title(string),author(string),price(float32),publish(bool)信息
zhangsan zhangsan 12.23 true
1.展現全部書籍
2.添加書籍
3.修改書籍
4.刪除書籍
5.退出
3
輸入要修改的書籍信息
輸入書籍的title(string),author(string),price(float32),publish(bool)信息
zhangsan Zhansan 231.1 false
書籍信息修改爲功!
1.展現全部書籍
2.添加書籍
3.修改書籍
4.刪除書籍
5.退出
1
書籍信息以下:
title:zhangsan author:Zhansan price:231.10 publish:false
1.展現全部書籍
2.添加書籍
3.修改書籍
4.刪除書籍
5.退出
4
輸入要刪除的書籍名稱
zhangsan
書籍刪除成功!
1.展現全部書籍
2.添加書籍
3.修改書籍
4.刪除書籍
5.退出
1
書籍信息以下:
1.展現全部書籍
2.添加書籍
3.修改書籍
4.刪除書籍
5.退出
5
Process finished with exit code 0


