go-面向對象編程（上）

一個程序就是一個世界，有不少對象(變量)

Golang 語言面向對象編程說明

1) Golang 也支持面向對象編程(OOP)，可是和傳統的面向對象編程有區別，並非純粹的面向對
象語言。因此咱們說 Golang 支持面向對象編程特性是比較準確的。
2) Golang 沒有類(class)，Go 語言的結構體(struct)和其它編程語言的類(class)有同等的地位，你可
以理解 Golang 是基於 struct 來實現 OOP 特性的。
3) Golang 面向對象編程很是簡潔，去掉了傳統 OOP 語言的繼承、方法重載、構造函數和析構函
數、隱藏的 this 指針等等

4) Golang 仍然有面向對象編程的 繼承，封裝和多態的特性，只是實現的方式和其它 OOP 語言不
同樣，好比繼承 ：Golang 沒有 extends 關鍵字，繼承是經過匿名字段來實現。
5) Golang 面向對象(OOP)很優雅，OOP 自己就是語言類型系統(type system)的一部分，經過接口
(interface)關聯，耦合性低，也很是靈活。也就是說在 Golang 中面
向接口編程是很是重要的特性。

結構體與結構體變量(實例/對象)的關係

1) 將一類事物的特性提取出來(好比貓類)， 造成一個新的數據類型， 就是一個結構體。
2) 經過這個結構體，咱們能夠建立多個變量(實例/對象)
3) 事物能夠貓類，也能夠是 Person ， Fish 或是某個工具類。。。

package main
import (
    "fmt"
)


//定義一個Cat結構體，將Cat的各個字段/屬性信息，放入到Cat結構體進行管理
type Cat struct {
    Name string 
    Age int 
    Color string 
    Hobby string
    Scores [3]int // 字段是數組...
}

func main() {

    // 張老太養了20只貓貓:一隻名字叫小白,今年3歲,白色。還有一隻叫小花,
    // 今年100歲,花色。請編寫一個程序，當用戶輸入小貓的名字時，就顯示該貓的名字，
    // 年齡，顏色。若是用戶輸入的小貓名錯誤，則顯示 張老太沒有這隻貓貓。

    // //1. 使用變量的處理
    // var cat1Name string = "小白"
    // var cat1Age int = 3
    // var cat1Color string = "白色"

    // var cat2Name string = "小花"
    // var cat2Age int = 100
    // var cat2Color string = "花色"

    // //2. 使用數組解決
    // var catNames [2]string = [...]string{"小白", "小花"}
    // var catAges [2]int = [...]int{3, 100}
    // var catColors [2]string = [...]string{"白色", "花色"}
    // //... map[string]string

    // fmt.Println("ok")

    // 使用struct來完成案例

    // 建立一個Cat的變量
    var cat1 Cat  // var a int
    
    fmt.Printf("cat1的地址=%p\n", &cat1)
    cat1.Name = "小白"
    cat1.Age = 3
    cat1.Color = "白色"
    cat1.Hobby = "吃<・)))><<"
    

    fmt.Println("cat1=", cat1)

    fmt.Println("貓貓的信息以下：")
    fmt.Println("name=", cat1.Name)
    fmt.Println("Age=", cat1.Age)
    fmt.Println("color=", cat1.Color)
    fmt.Println("hobby=", cat1.Hobby)

    

}

結構體和結構體變量(實例)的區別和聯繫

經過上面的案例和講解咱們能夠看出:
1) 結構體是自定義的數據類型，表明一類事物.
2) 結構體變量(實例)是具體的，實際的，表明一個具體變量
結構體變量(實例)在內存的佈局(重要!)

如何聲明結構體

基本語法

type 結構體名稱 struct {
field1 type
field2 type
}
 //舉例:
type Student struct {
Name string //字段
Age int //字段
Score float32
}

字段/屬性

基本介紹
1) 從概念或叫法上看： 結構體字段 = 屬性 = field （即授課中，統一叫字段)
2) 字段是結構體的一個組成部分，通常是 基本數據類型、 數組,也但是 引用類型。好比咱們前面定
義貓結構體 的 Name string 就是屬性

注意事項和細節說明
1) 字段聲明語法同變量，示例：字段名 字段類型
2) 字段的類型能夠爲：基本類型、數組或引用類型
3) 在建立一個結構體變量後，若是沒有給字段賦值，都對應一個零值(默認值)，規則同前面講的
同樣:
布爾類型是 false ，數值是 0 ，字符串是 ""。
數組類型的默認值和它的元素類型相關，好比 score [3]int 則爲[0, 0, 0]
指針，slice ，和 map 是 的零值都是 nil ，即尚未分配空間。
4)不一樣結構體變量的字段是獨立，互不影響，一個結構體變量字段的更改，不影響另一個, 結構體
是值類型。

package main
import (
    "fmt"
)

//若是結構體的字段類型是: 指針，slice，和map的零值都是 nil ，即尚未分配空間
//若是須要使用這樣的字段，須要先make，才能使用.

type Person struct{
    Name string
    Age int
    Scores [5]float64
    ptr *int //指針 
    slice []int //切片
    map1 map[string]string //map
}

type Monster struct{
    Name string
    Age int
}


func main() {

    //定義結構體變量
    var p1 Person
    fmt.Println(p1)

    if p1.ptr == nil {
        fmt.Println("ok1")
    }

    if p1.slice == nil {
        fmt.Println("ok2")
    }

    if p1.map1 == nil {
        fmt.Println("ok3")
    }

    //使用slice, 再次說明，必定要make
    p1.slice = make([]int, 10)
    p1.slice[0] = 100 //ok

    //使用map, 必定要先make
    p1.map1 = make(map[string]string)
    p1.map1["key1"] = "tom~" 
    fmt.Println(p1)

    //不一樣結構體變量的字段是獨立，互不影響，一個結構體變量字段的更改，
    //不影響另一個, 結構體是值類型
    var monster1 Monster
    monster1.Name = "牛魔王"
    monster1.Age = 500

    monster2 := monster1 //結構體是值類型，默認爲值拷貝
    monster2.Name = "青牛精"

    fmt.Println("monster1=", monster1) //monster1= {牛魔王 500}
    fmt.Println("monster2=", monster2) //monster2= {青牛精 500}

}

建立結構體變量和訪問結構體字段

方式 1-直接聲明

案例演示: var person Person
前面咱們已經說了。

方式 2-{}

案例演示: var person Person = Person{}

方式 3-&

案例: var person *Person = new (Person)

方式 4-{}

案例: var person *Person = &Person{}

說明:

1) 第 3 種和第 4 種方式返回的是 結構體指針。
2) 結構體指針訪問字段的標準方式應該是：(結構體指針).字段名 ，好比 (person).Name = "tom"
3) 但 go 作了一個簡化，持 也支持 結構體指針. 字段名, 好比 person.Name = "tom"。更加符合程序員
使用的習慣，go 層 編譯器底層 對 對 person.Name 化 作了轉化 (*person).Name

package main
import (
    "fmt"
)

type Person struct{
    Name string
    Age int
}
func main() {
    //方式1

    //方式2
    p2 := Person{"mary", 20}
    // p2.Name = "tom"
    // p2.Age = 18
    fmt.Println(p2)

    //方式3-&
    //案例: var person *Person = new (Person)

    var p3 *Person= new(Person)
    //由於p3是一個指針，所以標準的給字段賦值方式
    //(*p3).Name = "smith" 也能夠這樣寫 p3.Name = "smith"

    //緣由: go的設計者 爲了程序員使用方便，底層會對 p3.Name = "smith" 進行處理
    //會給 p3 加上 取值運算 (*p3).Name = "smith"
    (*p3).Name = "smith" 
    p3.Name = "john" //

    (*p3).Age = 30
    p3.Age = 100
    fmt.Println(*p3)

    //方式4-{}
    //案例: var person *Person = &Person{}

    //下面的語句，也能夠直接給字符賦值
    //var person *Person = &Person{"mary", 60} 
    var person *Person = &Person{}

    //由於person 是一個指針，所以標準的訪問字段的方法
    // (*person).Name = "scott"
    // go的設計者爲了程序員使用方便，也能夠 person.Name = "scott"
    // 緣由和上面同樣，底層會對 person.Name = "scott" 進行處理， 會加上 (*person)
    (*person).Name = "scott"
    person.Name = "scott~~"

    (*person).Age = 88
    person.Age = 10
    fmt.Println(*person)

}

struct 類型的內存分配機制

略

結構體使用注意事項和細節

1) 結構體的全部字段在 內存中是連續的

package main 
import "fmt"

//結構體
type Point struct {
    x int
    y int
}

//結構體
type Rect struct {
    leftUp, rightDown Point
}

//結構體
type Rect2 struct {
    leftUp, rightDown *Point
}

func main() {

    r1 := Rect{Point{1,2}, Point{3,4}} 

    //r1有四個int, 在內存中是連續分佈
    //打印地址
    fmt.Printf("r1.leftUp.x 地址=%p r1.leftUp.y 地址=%p r1.rightDown.x 地址=%p r1.rightDown.y 地址=%p \n", 
    &r1.leftUp.x, &r1.leftUp.y, &r1.rightDown.x, &r1.rightDown.y)

    //r2有兩個 *Point類型，這個兩個*Point類型的自己地址也是連續的，
    //可是他們指向的地址不必定是連續

    r2 := Rect2{&Point{10,20}, &Point{30,40}} 

    //打印地址
    fmt.Printf("r2.leftUp 自己地址=%p r2.rightDown 自己地址=%p \n", 
        &r2.leftUp, &r2.rightDown)

    //他們指向的地址不必定是連續...， 這個要看系統在運行時是如何分配
    fmt.Printf("r2.leftUp 指向地址=%p r2.rightDown 指向地址=%p \n", 
        r2.leftUp, r2.rightDown)

}

2) 結構體是用戶單獨定義的類型，和其它類型進行轉換時須要有徹底相同的字段(名字、個數和類
型)
3) 結構體進行 type 從新定義(至關於取別名)，Golang 認爲是新的數據類型，可是相互間能夠強轉
4) struct 的每一個字段上，能夠寫上一個 tag, 該 tag 能夠經過反射機制獲取，常見的使用場景就是 序
列化和反序列化

package main 
import "fmt"
import "encoding/json"

type A struct {
    Num int
}
type B struct {
    Num int
}

type Monster struct{
    Name string `json:"name"` // `json:"name"` 就是 struct tag
    Age int `json:"age"`
    Skill string `json:"skill"`
}
func main() {
    var a A
    var b B
    a.Num=1
    b.Num=2
    a = A(b) // ? 能夠轉換，可是有要求，就是結構體的的字段要徹底同樣(包括:名字、個數和類型！)
    fmt.Println(a, b)

    //1. 建立一個Monster變量
    monster := Monster{"牛魔王", 500, "芭蕉扇~"}

    //2. 將monster變量序列化爲 json格式字串
    //   json.Marshal 函數中使用反射，反射時，詳細介紹
    jsonStr, err := json.Marshal(monster)
    if err != nil {
        fmt.Println("json 處理錯誤 ", err)
    }
    fmt.Println("jsonStr", string(jsonStr))

}

方法

基本介紹

在某些狀況下，咱們要須要聲明(定義)方法。好比 Person 結構體:除了有一些字段外( 年齡，姓
名..),Person 結構體還有一些行爲好比:能夠說話、跑步..,經過學習，還能夠作算術題。這時就要用方法才能完成。
Golang 中的方法是 做用在指定的數據類型上的(即：和指定的數據類型綁定)，所以 自定義類型，
均可以有方法，而不只僅是 struct。

方法的聲明和調用

typeAstruct {
Num int
}
func (aA) test() {
fmt.Println(a.Num)
}

** 對上面的語法的說明**
1) func (aA) test() {} 表示 A 結構體有一方法，方法名爲 test
2) (aA) 體現 test 方法是和 A 類型綁定的

package main

import (
    "fmt"   
)

type Person struct {
    Name string
} 

//函數
//對於普通函數，接收者爲值類型時，不能將指針類型的數據直接傳遞，反之亦然

func test01(p Person) {
    fmt.Println(p.Name)
}

func test02(p *Person) {
    fmt.Println(p.Name)
}

//對於方法（如struct的方法），
//接收者爲值類型時，能夠直接用指針類型的變量調用方法，反過來一樣也能夠

func (p Person) test03() {
    p.Name = "jack"
    fmt.Println("test03() =", p.Name) // jack
}

func (p *Person) test04() {
    p.Name = "mary"
    fmt.Println("test03() =", p.Name) // mary
}

func main() {

    p := Person{"tom"}
    test01(p)
    test02(&p)

    p.test03()
    fmt.Println("main() p.name=", p.Name) // tom
    
    (&p).test03() // 從形式上是傳入地址，可是本質仍然是值拷貝

    fmt.Println("main() p.name=", p.Name) // tom


    (&p).test04()
    fmt.Println("main() p.name=", p.Name) // mary
    p.test04() // 等價 (&p).test04 , 從形式上是傳入值類型，可是本質仍然是地址拷貝

}

對上面的總結
1) test 方法和 Person 類型綁定
2) test 方法只能經過 Person 類型的變量來調用，而不能直接調用，也不能使用其它類型變量來調
用
3) func (p Person) test() {}... p 表示哪一個 Person 變量調用，這個 p 就是它的副本, 這點和函數傳參非
常類似。
4) p 這個名字，有程序員指定，不是固定, 好比修改爲 person 也是能夠

方法快速入門

1) 給 Person 結構體添加 speak 方法,輸出 xxx 是一個好人
2) 給 Person 結構體添加 jisuan 方法,能夠計算從 1+..+1000 的結果, 說明方法體內能夠函數同樣，
進行各類運算
3) 給 Person 結構體 jisuan2 方法,該方法能夠接收一個數 n，計算從 1+..+n 的結果
4) 給 Person 結構體添加 getSum 方法,能夠計算兩個數的和，並返回結果
5) 方法的調用

package main

import (
    "fmt"   
)

type Person struct{
    Name string
}

//給Person結構體添加speak 方法,輸出  xxx是一個好人
func (p Person) speak() {
    fmt.Println(p.Name, "是一個goodman~")
}

//給Person結構體添加jisuan 方法,能夠計算從 1+..+1000的結果, 
//說明方法體內能夠函數同樣，進行各類運算

func (p Person) jisuan() {
    res := 0
    for i := 1; i <= 1000; i++ {
        res += i
    }
    fmt.Println(p.Name, "計算的結果是=", res)
}

//給Person結構體jisuan2 方法,該方法能夠接收一個參數n，計算從 1+..+n 的結果
func (p Person) jisuan2(n int) {
    res := 0
    for i := 1; i <= n; i++ {
        res += i
    }
    fmt.Println(p.Name, "計算的結果是=", res)
}

//給Person結構體添加getSum方法,能夠計算兩個數的和，並返回結果
func (p Person) getSum(n1 int, n2 int) int {
    return n1 + n2
}

//給Person類型綁定一方法
func (person Person) test() {
    person.Name = "jack"
    fmt.Println("test() name=", person.Name) // 輸出jack
}

type Dog struct {

}

func main() {

    var p Person
    p.Name = "tom"
    p.test() //調用方法
    fmt.Println("main() p.Name=", p.Name) //輸出 tom
    //下面的使用方式都是錯誤的
    // var dog Dog  
    // dog.test()
    // test()

    //調用方法
    p.speak()
    p.jisuan()
    p.jisuan2(20)
    n1 := 10
    n2 := 20
    res := p.getSum(n1, n2)
    fmt.Println("res=", res)
}

方法的調用和傳參機制原理：(重要！)

說明：

方法的調用和傳參機制和函數基本同樣，不同的地方是方法調用時，會將調用方法的變量，當作
實參也傳遞給方法。下面咱們舉例說明。

說明:

1) 在經過一個變量去調用方法時，其調用機制和函數同樣
2) 不同的地方時，變量調用方法時，該變量自己也會做爲一個參數傳遞到方法(若是變量是值類
型，則進行值拷貝，若是變量是引用類型，則進行地質拷貝)

案例 2

請編寫一個程序，要求以下：
1) 聲明一個結構體 Circle, 字段爲 radius
2) 聲明一個方法 area 和 Circle 綁定，能夠返回面積。

package main

import (
    "fmt"   
)

type Circle struct {
    radius float64
}

//2)聲明一個方法area和Circle綁定，能夠返回面積。

func (c Circle) area() float64 {
    return 3.14 * c.radius * c.radius
}

//爲了提升效率，一般咱們方法和結構體的指針類型綁定
func (c *Circle) area2() float64 {
    //由於 c是指針，所以咱們標準的訪問其字段的方式是 (*c).radius
    //return 3.14 * (*c).radius * (*c).radius
    // (*c).radius 等價  c.radius 
    fmt.Printf("c 是  *Circle 指向的地址=%p", c)
    c.radius = 10
    return 3.14 * c.radius * c.radius
}
 
func main() {
// 1)聲明一個結構體Circle, 字段爲 radius
// 2)聲明一個方法area和Circle綁定，能夠返回面積。
// 3)提示：畫出area執行過程+說明

    //建立一個Circle 變量
    // var c Circle 
    // c.radius = 4.0
    // res := c.area()
    // fmt.Println("面積是=", res)

    //建立一個Circle 變量
    var c Circle 
    fmt.Printf("main c 結構體變量地址 =%p\n", &c)
    c.radius = 7.0
    //res2 := (&c).area2()
    //編譯器底層作了優化  (&c).area2() 等價 c.area()
    //由於編譯器會自動的給加上 &c
    res2 := c.area2()
    fmt.Println("面積=", res2)
    fmt.Println("c.radius = ", c.radius) //10


}

方法的聲明(定義)

func (recevier type) methodName（參數列表） (返回值列表){
方法體
return 返回值
}

1) 參數列表：表示方法輸入
2) recevier type : 表示這個方法和 type 這個類型進行綁定，或者說該方法做用於 type 類型
3) receiver type : type 能夠是結構體，也能夠其它的自定義類型
4) receiver : 就是 type 類型的一個變量(實例)，好比 ：Person 結構體 的一個變量(實例)
5) 返回值列表：表示返回的值，能夠多個
6) 方法主體：表示爲了 實現某一功能代碼塊
7) return 語句不是必須的。

方法的注意事項和細節

1) 結構體類型是值類型，在方法調用中，遵照值類型的傳遞機制，是值拷貝傳遞方式
2) 如程序員但願在方法中，修改結構體變量的值，能夠經過結構體指針的方式來處理
3) Golang 中的方法做用在指定的數據類型上的(即：和指定的數據類型綁定)，所以自定義類型，
均可以有方法，而不只僅是 struct， 好比 int , float32 等均可以有方法

package main

import (
    "fmt"   
)
/*
Golang中的方法做用在指定的數據類型上的(即：和指定的數據類型綁定)，所以自定義類型，
均可以有方法，而不只僅是struct， 好比int , float32等均可以有方法
*/

type integer int

func (i integer) print() {
    fmt.Println("i=", i)
}
//編寫一個方法，能夠改變i的值
func (i *integer) change() {
    *i = *i + 1
}

type Student struct {
    Name string
    Age int
}

//給*Student實現方法String()
func (stu *Student) String() string {
    str := fmt.Sprintf("Name=[%v] Age=[%v]", stu.Name, stu.Age)
    return str
}

func main() {
    var i integer = 10
    i.print()
    i.change()
    fmt.Println("i=", i)

    //定義一個Student變量
    stu := Student{
        Name : "tom",
        Age : 20,
    }
    //若是你實現了 *Student 類型的 String方法，就會自動調用
    fmt.Println(&stu) 
}

幾個小例子

1)編寫結構體(MethodUtils)，編程一個方法，方法不須要參數，在方法中打印一個 108 的矩形，
在 main 方法中調用該方法
2)編寫一個方法，提供 m 和 n 兩個參數，方法中打印一個 mn 的矩形
3) 編寫一個方法算該矩形的面積(能夠接收長 len，和寬 width)， 將其做爲方法返回值。在 main
方法中調用該方法，接收返回的面積值並打印。
4) 編寫方法：判斷一個數是奇數仍是偶數
5) 根據行、列、字符打印 對應行數和列數的字符，好比：行：3，列：2，字符*,則打印相應的效
果
6) 定義小小計算器結構體(Calcuator)，實現加減乘除四個功能
實現形式 1：分四個方法完成:
實現形式 2：用一個方法搞定

package main

import (
    "fmt"   
)

type MethodUtils struct {
    //字段...
}

//給MethodUtils編寫方法
func (mu MethodUtils) Print() {
    for i := 1; i <= 10; i++ {
        for j := 1; j <= 8; j++ {
            fmt.Print("*")
        }
        fmt.Println()
    }
}

//2)編寫一個方法，提供m和n兩個參數，方法中打印一個m*n的矩形
func (mu MethodUtils) Print2(m int, n int) {
    for i := 1; i <= m; i++ {
        for j := 1; j <= n; j++ {
            fmt.Print("*")
        }
        fmt.Println()
    }
}

/*
編寫一個方法算該矩形的面積(能夠接收長len，和寬width)， 
將其做爲方法返回值。在main方法中調用該方法，接收返回的面積值並打印
*/

func (mu MethodUtils) area(len float64, width float64) (float64) {
    return len * width
}

/*
編寫方法：判斷一個數是奇數仍是偶數

*/

func (mu *MethodUtils) JudgeNum(num int)  {
    if num % 2 == 0 {
        fmt.Println(num, "是偶數..")   
    } else {
        fmt.Println(num, "是奇數..")   
    }
}
/*
根據行、列、字符打印 對應行數和列數的字符，
好比：行：3，列：2，字符*,則打印相應的效果

*/

func (mu *MethodUtils) Print3(n int, m int, key string)  {
    
    for i := 1; i <= n ; i++ {
        for j := 1; j <= m; j++ {
            fmt.Print(key)
        }
        fmt.Println()
    }
}

/*
定義小小計算器結構體(Calcuator)，
實現加減乘除四個功能
實現形式1：分四個方法完成: , 分別計算 + - * /
實現形式2：用一個方法搞定, 須要接收兩個數，還有一個運算符 

*/
//實現形式1

type Calcuator struct{
    Num1 float64
    Num2 float64
}

func (calcuator *Calcuator) getSum() float64 {

    return calcuator.Num1 + calcuator.Num2
}

func (calcuator *Calcuator) getSub() float64 {

    return calcuator.Num1 - calcuator.Num2
}

//..

//實現形式2

func (calcuator *Calcuator) getRes(operator byte) float64 {
    res := 0.0
    switch operator {
    case '+':
            res = calcuator.Num1 + calcuator.Num2
    case '-':
            res = calcuator.Num1 - calcuator.Num2
    case '*':
            res = calcuator.Num1 * calcuator.Num2
    case '/':
            res = calcuator.Num1 / calcuator.Num2
    default:
            fmt.Println("運算符輸入有誤...")
            
    }
    return res
}


func main() {
    /*
    1)編寫結構體(MethodUtils)，編程一個方法，方法不須要參數，
    在方法中打印一個10*8 的矩形，在main方法中調用該方法。
    */
    var mu MethodUtils
    mu.Print()
    fmt.Println()
    mu.Print2(5, 20)

    areaRes := mu.area(2.5, 8.7)
    fmt.Println()
    fmt.Println("面積爲=", areaRes)

    mu.JudgeNum(11)

    mu.Print3(7, 20, "@")


    //測試一下:
    var calcuator Calcuator
    calcuator.Num1 = 1.2
    calcuator.Num2 = 2.2
    fmt.Printf("sum=%v\n", fmt.Sprintf("%.2f",calcuator.getSum()))
    fmt.Printf("sub=%v\n",fmt.Sprintf("%.2f",calcuator.getSub()))


    res := calcuator.getRes('*')
    fmt.Println("res=", res)

}

方法和函數區別

1) 調用方式不同
函數的調用方式: 函數名(實參列表)
方法的調用方式: 變量.方法名(實參列表)
2) 對於普通函數，接收者爲值類型時，不能將指針類型的數據直接傳遞，反之亦然
3) 對於方法（如 struct 的方法），接收者爲值類型時，能夠直接用指針類型的變量調用方法，反
過來一樣也能夠

package main

import (
    "fmt"   
)

type Person struct {
    Name string
} 

//函數
//對於普通函數，接收者爲值類型時，不能將指針類型的數據直接傳遞，反之亦然

func test01(p Person) {
    fmt.Println(p.Name)
}

func test02(p *Person) {
    fmt.Println(p.Name)
}

//對於方法（如struct的方法），
//接收者爲值類型時，能夠直接用指針類型的變量調用方法，反過來一樣也能夠

func (p Person) test03() {
    p.Name = "jack"
    fmt.Println("test03() =", p.Name) // jack
}

func (p *Person) test04() {
    p.Name = "mary"
    fmt.Println("test03() =", p.Name) // mary
}

func main() {

    p := Person{"tom"}
    test01(p)
    test02(&p)

    p.test03()
    fmt.Println("main() p.name=", p.Name) // tom
    
    (&p).test03() // 從形式上是傳入地址，可是本質仍然是值拷貝

    fmt.Println("main() p.name=", p.Name) // tom


    (&p).test04()
    fmt.Println("main() p.name=", p.Name) // mary
    p.test04() // 等價 (&p).test04 , 從形式上是傳入值類型，可是本質仍然是地址拷貝

}

總結:
1) 無論調用形式如何，真正決定是值拷貝仍是地址拷貝，看這個方法是和哪一個類型綁定.
2) 若是是和值類型，好比 (p Person) , 則是值拷貝， 若是和指針類型，好比是 (p *Person) 則
是地址拷貝。

面向對象編程應用實例

步驟

1) 聲明(定義)結構體，肯定結構體名
2) 編寫結構體的字段
3) 編寫結構體的方法

學生案例：

1) 編寫一個 Student 結構體，包含 name、gender、age、id、score 字段，分別爲 string、string、int、
int、float64 類型。
2) 結構體中聲明一個 say 方法，返回 string 類型，方法返回信息中包含全部字段值。
3) 在 main 方法中，建立 Student 結構體實例(變量)，並訪問 say 方法，並將調用結果打印輸出。
4) 走代碼

import (
"fmt"
)
/*
學生案例：
編寫一個 Student 結構體，包含 name、gender、age、id、score 字段，分別爲 string、string、int、int、
float64 類型。
結構體中聲明一個 say 方法，返回 string 類型，方法返回信息中包含全部字段值。
在 main 方法中，建立 Student 結構體實例(變量)，並訪問 say 方法，並將調用結果打印輸出。
*/
type Student struct {
    name string
    gender string
    age int
    id int
    score float64
}
func (student *Student) say() string {
    infoStr := fmt.Sprintf("student 的信息 name=[%v] gender=[%v], age=[%v] id=[%v] score=[%v]",
    student.name, student.gender, student.age, student.id, student.score)
    return infoStr
}
func main() {
//測試
//建立一個 Student 實例變量
var stu = Student{
    name : "tom",
    gender : "male",
    age : 18,
    id : 1000,
    score : 99.98,
}
   fmt.Println(stu.say())
}

盒子案例

1) 編程建立一個 Box 結構體，在其中聲明三個字段表示一個立方體的長、寬和高，長寬高要從終
端獲取
2) 聲明一個方法獲取立方體的體積。
3) 建立一個 Box 結構體變量，打印給定尺寸的立方體的體積
4) 走代碼

景區門票案例

1) 一個景區根據遊人的年齡收取不一樣價格的門票，好比年齡大於 18，收費 20 元，其它狀況門票免
費.
2) 請編寫 Visitor 結構體，根據年齡段決定可以購買的門票價格並輸出
3) 代碼：

package main

import (
    "fmt"   
)

/*
學生案例：
編寫一個Student結構體，包含name、gender、age、id、score字段，分別爲string、string、int、int、float64類型。
結構體中聲明一個say方法，返回string類型，方法返回信息中包含全部字段值。
在main方法中，建立Student結構體實例(變量)，並訪問say方法，並將調用結果打印輸出。

*/
type Student struct {
    name string
    gender string
    age int
    id int
    score float64
}

func (student *Student) say()  string {

    infoStr := fmt.Sprintf("student的信息 name=[%v] gender=[%v], age=[%v] id=[%v] score=[%v]",
        student.name, student.gender, student.age, student.id, student.score)

    return infoStr
}

/*
1)編程建立一個Box結構體，在其中聲明三個字段表示一個立方體的長、寬和高，長寬高要從終端獲取
2)聲明一個方法獲取立方體的體積。
3)建立一個Box結構體變量，打印給定尺寸的立方體的體積
*/
type Box struct {
    len float64
    width float64
    height float64
}

//聲明一個方法獲取立方體的體積
func (box *Box) getVolumn() float64 {
    return box.len * box.width * box.height
}


// 景區門票案例

// 一個景區根據遊人的年齡收取不一樣價格的門票，好比年齡大於18，收費20元，其它狀況門票免費.
// 請編寫Visitor結構體，根據年齡段決定可以購買的門票價格並輸出

type Visitor struct {
    Name string
    Age int
}

func (visitor *Visitor) showPrice() {
    if visitor.Age >= 90 || visitor.Age <=8 {
        fmt.Println("考慮到安全，就不要玩了")
        return 
    }
    if visitor.Age > 18 {
        fmt.Printf("遊客的名字爲 %v 年齡爲 %v 收費20元 \n", visitor.Name, visitor.Age)
    } else {
        fmt.Printf("遊客的名字爲 %v 年齡爲 %v 免費 \n", visitor.Name, visitor.Age)
    }
}



func main() {
    //測試
    //建立一個Student實例變量
    var stu = Student{
        name : "tom",
        gender : "male",
        age : 18,
        id : 1000,
        score : 99.98,
    }
    fmt.Println(stu.say())

    //測試代碼
    var box Box
    box.len = 1.1
    box.width = 2.0
    box.height = 3.0
    volumn := box.getVolumn()
    fmt.Printf("體積爲=%.2f", volumn)


    //測試
    var v Visitor
    for {
        fmt.Println("請輸入你的名字")
        fmt.Scanln(&v.Name)
        if v.Name == "n" {
            fmt.Println("退出程序....")
            break
        }
        fmt.Println("請輸入你的年齡")
        fmt.Scanln(&v.Age)
        v.showPrice()

    }
}

建立結構體變量時指定字段值

說明
Golang 在建立結構體實例(變量)時，能夠直接指定字段的值

package main

import (
    "fmt"   
)
type Stu struct {
    Name string
    Age int
}

func main() {

    //方式1
    //在建立結構體變量時，就直接指定字段的值
    var stu1 = Stu{"小明", 19} // stu1---> 結構體數據空間
    stu2 := Stu{"小明~", 20}

    //在建立結構體變量時，把字段名和字段值寫在一塊兒, 這種寫法，就不依賴字段的定義順序.
    var stu3 = Stu{
            Name :"jack",
            Age : 20,
        }
    stu4 := Stu{
        Age : 30,
        Name : "mary",
    }
    
    fmt.Println(stu1, stu2, stu3, stu4)

    //方式2， 返回結構體的指針類型(!!!)
    var stu5 *Stu = &Stu{"小王", 29}  // stu5--> 地址 ---》 結構體數據[xxxx,xxx]
    stu6 := &Stu{"小王~", 39}

    //在建立結構體指針變量時，把字段名和字段值寫在一塊兒, 這種寫法，就不依賴字段的定義順序.
    var stu7 = &Stu{
        Name : "小李",
        Age :49,
    }
    stu8 := &Stu{
        Age :59,
        Name : "小李~",
    }
    fmt.Println(*stu5, *stu6, *stu7, *stu8) //

}

工廠模式

Golang 的結構體沒有構造函數，一般可使用工廠模式來解決這個問題。

看一個需求

一個結構體的聲明是這樣的:
package model
type Student struct {
Name string...
}
由於這裏的 Student 的首字母 S 是大寫的，若是咱們想在其它包建立 Student 的實例(好比 main 包)，
引入 model 包後，就能夠直接建立 Student 結構體的變量(實例)。 可是問題來了 ， 若是首字母是小寫的 ，
如 好比 是 是 type student struct {....} 就不不行了，怎麼辦---> 工廠模式來解決.

工廠模式來解決問題

使用工廠模式實現跨包建立結構體實例(變量)的案例:
若是 model 包的 結構體變量首字母大寫，引入後，直接使用, 沒有問題
若是 model 包的 結構體變量首字母小寫，引入後，不能直接使用, 能夠 工廠模式解決， 看老師演
示， 代碼:
student.go

package model

//定義一個結構體
type student struct{
    Name string
    score float64
}

//由於student結構體首字母是小寫，所以是隻能在model使用
//咱們經過工廠模式來解決

func NewStudent(n string, s float64) *student {
    return &student{
        Name : n,
        score : s,
    }
}

//若是score字段首字母小寫，則，在其它包不能夠直接方法，咱們能夠提供一個方法
func (s *student) GetScore() float64{
    return s.score //ok
}

main.go

package main
import (
    "fmt"
    "go_code/chapter10/factory/model"
)

func main() {
    //建立要給Student實例
    // var stu = model.Student{
    //  Name :"tom",
    //  Score : 78.9,
    // }

    //定student結構體是首字母小寫，咱們能夠經過工廠模式來解決
    var stu = model.NewStudent("tom~", 98.8)

    fmt.Println(*stu) //&{....}
    fmt.Println("name=", stu.Name, " score=", stu.GetScore())
}