go-面向對象編程（上）

来源:https://www.cnblogs.com/ygjzs/archive/2019/11/07/11816953.html
-Advertisement-
Play Games

一個程式就是一個世界，有很多對象(變數) Golang 語言面向對象編程說明 1) Golang 也支持面向對象編程(OOP)，但是和傳統的面向對象編程有區別，並不是純粹的面向對 象語言。所以我們說 Golang 支持面向對象編程特性是比較準確的。 2) Golang 沒有類(class)，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())
}

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • ZK中使用JS讀取客戶端txt文件內容問題
    最近寫一個需求時遇到一個問題,用戶需要通過點擊一個按鈕直接讀取他自己電腦上D盤的一個txt文件內容顯示到頁面,因為項目現在是用ZK寫的.我對於ZK也是剛剛瞭解不就,很多都還不是很熟.起初我是想用io流去讀取,然後寫完發現,這樣每次讀取的都是伺服器上的D盤下的txt文件,所以在網上找了很久.很多都是獲 ...
  • Nginx配置實例-反向代理實例：根據訪問的路徑跳轉到不同埠的服務中
    場景 Ubuntu Server 16.04 LTS上怎樣安裝下載安裝Nginx並啟動： https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/102828075 Nginx的配置文件位置以及組成部分結構講解： https://blog. ...
  • 再小的應用也有架構，面向架構新手的架構實踐！
    文章主人公：小明，就職於某互聯網公司，從事後端開發工作。最近小明收到通知公司需要開發一款《證件照》應用，需要徵集架構方案，主要功能包括： 小明雖然從事後端開發工作，但是一直很關註架構這方面的知識，以往都是開發大佬們架構好的應用現在有機會自己去實踐下，打算把自己學到的知識應用於實際案例中來。 小明的腦 ...
  • Python win32com模塊 合併文件夾內多個docx文件為一個docx
    Python win32com模塊 合併文件夾內多個docx文件為一個docx #!/usr/bin/env python # -*- coding: utf-8 -*- from win32com.client import Dispatch import os,sys #import panda ...
  • Java之路---Day19(set介面)
    set介面 java.util.Set 介面和 java.util.List 介面一樣，同樣繼承自 Collection 介面，它與 Collection 介面中的方 法基本一致,但是set介面中元素無序,並且不重覆 分類 1.HashSet集合 2.LinkedHashSet集合 HashSet集 ...
  • 起源
    day one 演算法是充分利用解題環境所提供的基本操作，對輸入數據進行 逐步加工、變換和處理，從而達到解決問題的目的。 電腦的基本功能操作包括以下四個方面： 邏輯運算：與、或、非； 算術運算：加、減、乘、除； 數據比較：大於、小於、等於、不等於、大於等於、小於等於； 數據傳送：輸入、輸出、賦值。 ...
  • 用迴圈隊列解決舞伴配對問題發現自己的問題
    1.首先是對vs2017這款軟體的使用 1.VS中的scanf（）這個函數的使用問題 直到這次寫代碼我才知道VS中用scanf是會被警告的，VS中正規的類似於scanf（）函數的輸入函數是scanf_s()只有使用這個函數你才不會報錯，它有三個參分別是數據類型，地址，最大存儲量， 還有兩種方法 第一 ...
  • [Linux] 純凈ubuntu快速搭建寶塔面板
    寶塔官方建議是純凈的系統，我使用docker運行一個ubuntu容器，模擬一個純凈的系統，這樣也不會影響到我的其他服務。 docker run --name baota -id -p 8888:8888 ubuntu docker exec -it baota bashapt-get updatea ...
一周排行
    -Advertisement-
    Play Games
  • Dapr Outbox 執行流程
    Dapr Outbox 是1.12中的功能。 本文只介紹Dapr Outbox 執行流程，Dapr Outbox基本用法請閱讀官方文檔 。本文中appID=order-processor，topic=orders 本文前提知識：熟悉Dapr狀態管理、Dapr發佈訂閱和Outbox 模式。 Outbo ...
  • Advanced .Net Debugging 7：托管堆與垃圾收集
    引言 在前幾章我們深度講解了單元測試和集成測試的基礎知識，這一章我們來講解一下代碼覆蓋率,代碼覆蓋率是單元測試運行的度量值,覆蓋率通常以百分比表示，用於衡量代碼被測試覆蓋的程度，幫助開發人員評估測試用例的質量和代碼的健壯性。常見的覆蓋率包括語句覆蓋率（Line Coverage）、分支覆蓋率（Bra ...
  • C#S7.NET實現西門子PLCDB塊數據採集的完整步驟
    前言 本文介紹瞭如何使用S7.NET庫實現對西門子PLC DB塊數據的讀寫，記錄了使用電腦模擬，模擬PLC，自至完成測試的詳細流程，並重點介紹了在這個過程中的易錯點，供參考。 用到的軟體： 1.Windows環境下鏈路層網路訪問的行業標準工具（WinPcap_4_1_3.exe）下載鏈接：http ...
  • WPF控制項：密碼框綁定MVVM
    從依賴倒置原則（Dependency Inversion Principle, DIP）到控制反轉（Inversion of Control, IoC）再到依賴註入（Dependency Injection, DI）的演進過程，我們可以理解為一種逐步抽象和解耦的設計思想。這種思想在C#等面向對象的編 ...
  • Python中的私有屬性與私有方法
    關於Python中的私有屬性和私有方法 Python對於類的成員沒有嚴格的訪問控制限制，這與其他面相對對象語言有區別。關於私有屬性和私有方法，有如下要點： 1、通常我們約定，兩個下劃線開頭的屬性是私有的（private）。其他為公共的（public）； 2、類內部可以訪問私有屬性（方法）； 3、類外 ...
  • C++ 訪問說明符詳解：封裝數據，控制訪問，提升安全性
    C++ 訪問說明符 訪問說明符是 C++ 中控制類成員（屬性和方法）可訪問性的關鍵字。它們用於封裝類數據並保護其免受意外修改或濫用。 三種訪問說明符： public：允許從類外部的任何地方訪問成員。 private：僅允許在類內部訪問成員。 protected：允許在類內部及其派生類中訪問成員。 示 ...
  • static_cast與dynamic_cast到底是什麼？
    寫這個隨筆說一下C++的static_cast和dynamic_cast用在子類與父類的指針轉換時的一些事宜。首先，【static_cast，dynamic_cast】【父類指針，子類指針】，兩兩一組，共有4種組合：用 static_cast 父類轉子類、用 static_cast 子類轉父類、使用 ...
  • C語言數據結構：雙向鏈表的增刪操作
    /******************************************************************************************************** * * * 設計雙向鏈表的介面 * * * * Copyright (c) 2023-2 ...
  • @ComponentScan註解的實現，Spring掃描包的過程
    相信接觸過spring做開發的小伙伴們一定使用過@ComponentScan註解 @ComponentScan("com.wangm.lifecycle") public class AppConfig { } @ComponentScan指定basePackage，將包下的類按照一定規則註冊成Be ...
  • opensips開啟python支持
    操作系統 ：CentOS 7.6_x64 opensips版本： 2.4.9 python版本：2.7.5 python作為腳本語言，使用起來很方便，查了下opensips的文檔，支持使用python腳本寫邏輯代碼。今天整理下CentOS7環境下opensips2.4.9的python模塊筆記及使用 ...
所有分類