Go 面向对象

golang之指针

package main

import "fmt"

type myInt int
//匿名函数
//值的接收
//指针的接收
//*myint表示myInt的指针类型
// *i表示指针i，指向i的值
func (i *myInt) add(another int) myInt {
    *i = *i + myInt(another)
    return *i
}
//i1与i是两个变量,传递值
func main() {
    i1 := myInt(1)
    i2 := i1.add(2)
    fmt.Println(i1,i2)

}

值方法，指针方法遵循了如下规则：

接受者变量代表的值实际上是源值的复制品。如果这个值不是指针类型，在值方法中就没有途径去改变源值。

而指针值与其复制品指向的是同一个值，所以在指针方法中就存在了改变源值的途径。

如果接受者类型是引用类型或者它的别名类型，即使是值方法，也可以改变源值

-------------

对于某个非指针的数据类型，与它关联的方法的集合中只包含它的值方法。而对于它的指针类型，其方法集合中只包含它的值方法也包含指针方法。

在非指针数据类型的值上，也是能够调用其指针方法的。

这是因为GO在内部做了自动转换。

例如add方法是指针方法，那么表达式i1.add(2)会被自动转换为(&i1).add(2)

第二条规则对于编写接口类型的实现类型来说很重要。 

Golang之排序算法

冒泡排序

package main

//冒泡排序
import "fmt"

func bsort(a []int) {
    for i := 0; i < len(a); i++ {
        for j := 1; j < len(a)-i; j++ {
            if a[j] < a[j-1] {
                a[j], a[j-1] = a[j-1], a[j]
            }
        }
    }
}
func main() {
    b := [...]int{8, 7, 5, 4, 3, 10, 15}
    bsort(b[:])
    fmt.Println(b)
}

选择排序

package main

import "fmt"

//冒泡排序

func ssort(a []int) {
    for i := 0; i < len(a); i++ {
        var min int = i
        for j := i + 1; j < len(a); j++ {
            if a[min] > a[j] {
                min = j
            }
        }
        a[i], a[min] = a[min], a[i]

    }
}

func main() {
    b := [...]int{8, 7, 5, 4, 3, 10, 15}
    ssort(b[:])
    fmt.Println(b)
}

插入排序

package main

import "fmt"

//冒泡排序

func isort(a []int) {
    for i := 1; i < len(a); i++ {
        for j := i; j > 0; j-- {
            if a[j] > a[j-1] {
                break
            }
            a[j], a[j-1] = a[j-1], a[j]
        }
    }
}

func main() {
    b := [...]int{8, 7, 5, 4, 3, 10, 15}
    isort(b[:])
    fmt.Println(b)
}

快速排序

package main

import "fmt"

//快速排序

func qsort(a []int, left, right int) {
    if left >= right {
        return
    }
    val := a[left]
    k := left
    //确定val所在的位置
    for i := left + 1; i <= right; i++ {
        if a[i] < val {
            a[k] = a[i]
            a[i] = a[k+1]
            k++
        }
    }
    a[k] = val
    qsort(a, left, k-1)
    qsort(a, k+1, right)
}
func main() {
    b := [...]int{8, 7, 5, 4, 3, 10}
    qsort(b[:], 0, len(b)-1)
    fmt.Println(b)
}

Golang之struct

1.用来定义复杂数据结构

2.struct里面可以包含多个字段（属性）

3.struct类型可以定义方法，注意和函数的区分。

4.struct类型是值类型

5.struct类型可以嵌套

6.Go语言没有class类型，只有struct类型

package main

import "fmt"

//声明结构体
type Student struct {
    Name  string
    Age   int
    Score int
}

func main() {
    //struct字段访问，使用“点”访问
    var stu Student
    stu.Name = "yuchao"
    stu.Age = 18
    stu.Score = 99
    fmt.Printf("name=%s age=%d scrore=%d", stu.Name, stu.Age, stu.Score)
}

定义struct的三种形式：

package main

import "fmt"

//声明结构体
//字段名和函数名一样，首字母大写，在包外可以访问
type Student struct {
    Name  string
    Age   int
    Score float32
}

func main() {
    //struct字段访问，使用“点”访问
    var stu Student
    //var stu *Student = new(Student)
    //var stu *Student = &Student{ }
    stu.Name = "yuchao"
    stu.Age = 18
    stu.Score = 99
    //fmt.Println(stu) //默认结构 {yuchao 18 99.1}
    //fmt.Printf("name=%s age=%d scrore=%d", stu.Name, stu.Age, stu.Score)

    var stu1 *Student = &Student{
        Age:  20,
        Name: "chao",
    }

    var stu3 = Student{
        Age:  20,
        Name: "hua",
    }

    fmt.Println(stu1)
    fmt.Println(stu3.Name)
    fmt.Printf("Name:%p
", &stu.Name)
    fmt.Printf("age:%p
", &stu.Age)
    fmt.Printf("score:%p
", &stu.Score)
}

var stu Student
var stu *Student = new(Student)
var stu *Student = &Student{ }

struct的内存布局，struct中的所有字段在内存是连续的，布局如下：

Golang之面向对象和指针

package main

import "fmt"

type Integer int

//为内置的int类型增加了新方法less，面向对象写法
func (a Integer) Less(b Integer) bool {
    return a < b
}
func Integer_Less(a Integer, b Integer) bool {
    return a < b
}

//Go的面向对象，如果需要修改对象，必须用指针，这不是Go约束，还是自然约束
func (a *Integer) Add(b Integer) {
    *a += b
}

//Integer类型是一个int，为int起一个别名Integer，
//             并且增加一系列方法Add，Add2，又编程了一个新的类型，这个类型还完全拥有int的功能
//传递值而不是指针
func (a Integer) Add2(b Integer) {
    a += b
    fmt.Println(a)
    fmt.Println(b)
}


func main() {
    var a Integer = 1
    if a.Less(2) {
        fmt.Println(a, "Less 2")
    }
    if Integer_Less(a, 2) {
        fmt.Println(a, "Less 2")
    }
    //为Integer又加了Add方法，Add（）方法需要修改对象的值，需要指针引用
    //a.Add(2)
    //fmt.Println("a=", a)
    //实现成员方法传入的如果不是指针，而是值，也就是Integer，而非*Iteger,，这时a=1
    a.Add2(2)
    fmt.Println("a=", a)
    //Go语言和C语言一样，类型都是基于值传递，想要修改变量的值，只能传递指针
}

/*
Go语言中没有隐藏的this指针
方法施加的目标（“对象”）显示传递，没有被隐藏
方法施加的目标（“对象”）不需要非得是指针，也不用非得叫this

*/

//值语义和引用语义
//b=a
//b.Modify()
//如果b的修改，不影响a的值，那么此类型就是值类型
//如果会影响a的值，那么此类型就是引用类型
//Go语言大多类型都是值语义
//基本类型：byte、int、bool、float32、float64、string等
//复合类型：数组（array）、结构体（struct）和指针（point）
//数组被完整的复制，就是值语义

func main() {
var a=[3]int{1,2,3}
var b=a //表示b=a赋值语句，是数组内容的完整复制
b[1]++
fmt.Println(a,b)
}

//引用方法，需要使用指针
func main() {
    var a = [3]int{1, 2, 3}
    var b = &a //这句赋值，是数组内容的引用，变量b类型是*[3]int类型
    b[1]++
    fmt.Print(a, *b)
}

Golang之Struct（二叉树定义）

package main

import "fmt"

//二叉树结构体
//如果每个节点有两个指针，分别用来指向左子树和右子树，我们把这样的结构叫做二叉树
type Student struct {
    Name  string
    Age   int
    Score float32
    left  *Student
    right *Student
}

func trans(root *Student) {
    if root == nil {
        return
    }
    //fmt.Println(root) //前序遍历
    trans(root.left)
    //fmt.Println(root) //中序遍历
    trans(root.right)
    fmt.Println(root) //后序遍历
}

func main() {
    var root *Student = new(Student)

    root.Name = "stu01"
    root.Age = 18
    root.Score = 100

    var left1 *Student = new(Student)
    left1.Name = "stu02"
    left1.Age = 18
    left1.Score = 100

    root.left = left1

    var right1 *Student = new(Student)
    right1.Name = "Stu04"
    right1.Age = 18
    right1.Score = 100

    root.right = right1

    var left2 *Student = new(Student)
    left2.Name = "Stu03"
    left2.Age = 18
    left2.Score = 100

    left1.left = left2
    trans(root)
}

Golang之方法（自定义类型，struct）

方法的使用，请看本天师的代码

//Golang的方法定义
//Golang中的方法是作用在特定类型的变量上，因此自定义类型，都可以有方法，不仅仅是struct
//定义：func (recevier type) methodName(参数列表)(返回值列表){}
//方法和函数的区别
/*
1，函数调用：function(variable，参数列表)
2， 方法，variable.function(参数列表)
方法的控制，通过大小写空格控制
 */

package main

//Golang的方法定义
//Golang中的方法是作用在特定类型的变量上，因此自定义类型，都可以有方法，不仅仅是struct
//定义：func (recevier type) methodName(参数列表)(返回值列表){}
import "fmt"

type integer int

func (p integer) print() {
    fmt.Println("p is:", p)
}
//这里传递的是副本，想改变p的值，需要传递指针
func (p *integer) set(b integer) {
    *p = b
}

type Student struct {
    Name  string
    Age   int
    Score int
    sex   int
}

//这里需要接受指针 *Student（接收者），否则修改不了值
func (p *Student) init(name string, age int, score int) {
    p.Name = name
    p.Age = age
    p.Score = score
    fmt.Println(p)
}
func (p Student) get() Student {
    return p
}

func main() {
    var stu Student
    //修改地址的写法(&stu).init
    //但是go可以自动知道，接受者是指针，这里stu就传递地址
    stu.init("stu", 18, 99)
    stu1 := stu.get()
    fmt.Println(stu1)

    //type integer方法
    var a integer
    a = 100
    a.print()
    a.set(1000)
    a.print()
}

Golang之继承，多重继承（struct）

package main

import "fmt"

/*
继承
一个结构体嵌到另一个结构体，称作组合
匿名和组合的区别
如果一个struct嵌套了另一个匿名结构体，那么这个结构可以直接访问匿名结构体的方法，从而实现继承
如果一个struct嵌套了另一个【有名】的结构体，那么这个模式叫做组合
如果一个struct嵌套了多个匿名结构体，那么这个结构可以直接访问多个匿名结构体的方法，从而实现多重继承
*/

type Car struct {
    weight int
    name   string
}

func (p *Car) Run() {
    fmt.Println("running")
}

type Bike struct {
    Car
    lunzi int
}
type Train struct {
    Car
}

func (p *Train) String() string {
    str := fmt.Sprintf("name=[%s] weight=[%d]", p.name, p.weight)
    return str
}

func main() {
    var a Bike
    a.weight = 100
    a.name = "bike"
    a.lunzi = 2
    fmt.Println(a)
    a.Run()

    var b Train
    b.weight = 100
    b.name = "train"
    b.Run()
    fmt.Printf("%s", &b)
}

 练习2

package main

import (
    "fmt"
    "time"
)

type Car struct {
    Name string
    Age  int
}

func (c *Car) Set(name string, age int) {
    c.Name = name
    c.Age = age
}

type Car2 struct {
    Name string
}

//Go有匿名字段特性
type Train struct {
    Car
    Car2
    createTime time.Time
    //count int   正常写法，Go的特性可以写成
    int
}

//给Train加方法，t指定接受变量的名字，变量可以叫this，t，p
func (t *Train) Set(age int) {
    t.int = age
}

func main() {
    var train Train
    train.int = 300 //这里用的匿名字段写法，给Age赋值
    //(&train).Set(1000)
    train.Car.Set("huas", 100 )
    train.Car.Name = "test" //这里Name必须得指定结构体
    fmt.Println(train)

}

Golang之接口（interface）

Golang最重要的接口，，，，

package main

import (
    "fmt"
)

//interface类型默认是指针
/*
接口的实现
Golang中的接口，不需要显示的实现。只需要一个变量，含有接口类型中的所有方法，那么这个变量就实现这个接口
因为Golang中没有implement类似的关键字
如果一个变量含有了多个interface类型的方法，那么这个变量就实现了多个接口
如果一个变量只含有了1个interface的部分方法，那么这个变量没有实现这个接口..

一种事物的多种形态，都可以按照统一的接口进行操作

*/

//接口嵌套
type ReadWrite interface {
    Read(b Buffer) bool
    Write(b Buffer) bool
}
type Lock interface {
    Lock()
    Unlock()
}
//嵌套，继承了前面四个方法，File就有6个方法
type File interface {
    ReadWrite
    Lock
    Close()
}
//类型断言，由于接口是一般类型，不知道具体类型，如果要转成具体类型可以采用以下方法进行转换
var t int
var x interface{}
x=t
y,ok=x.(int)



//定义People结构体
type People struct {
    name string
    age  int
}

//定义Test接口
type Test interface {
    //接口有2个方法
    Print()
    Sleep()
}

//定义struct
type Student struct {
    name  string
    age   int
    score int
}

//定义Print（）方法
func (p Student) Print() {
    fmt.Println("name:", p.name)
    fmt.Println("age:", p.age)
    fmt.Println("score", p.score)
}

//Sleep方法
func (p Student) Sleep() {
    fmt.Println("student sleep")
}
func (people People) Print() {
    fmt.Println("name:", people.name)
    fmt.Println("age:", people.age)
}
func (p People) Sleep() {
    fmt.Println("People Sleep")
}

func main() {
    var t Test
    //接口是个地址
    fmt.Println(t)

    var stu Student = Student{
        name:  "stu1",
        age:   20,
        score: 200,
    }
    t = stu
    t.Print()
    t.Sleep()
    fmt.Println("t:", t)

}

 //接口，空接口

package main

import "fmt"

type Carer interface {
    GetName() string
    Run()

    }

func main() {
    var a interface{} //空接口
    var b int         //具体类型
    //空接口可以保持任何类型的变量
    a = b                           // b给a赋值，空接口可以容纳任何类型    b=a //这是错的
    fmt.Printf("type of a:%T
", a) // %T打印类型
}

 //接口的实现（车，宝马车）

package main

import "fmt"

type Carer interface {
    GetName() string
    Run()
    DiDi()
}
type BMW struct {
    Name string
}

//得实现接口所有的方法，才算实现了该接口
func (p *BMW) GetName() string {
    return p.Name
}

//因此还得实现RUN()
//指针类型*BMW,也可以写值类型 (p BMW)
func (p *BMW) Run() {
    fmt.Printf("%s is running
", p.Name)
}

//还得实现DiDi()
func (p *BMW) DiDi() {
    fmt.Printf("%s is didi
", p.Name)
}
func main() {
    var car Carer
    fmt.Println(car)
    //var bmw BMW
    //bmw.Name = "BMW"
    //写法2
    bmw := &BMW{
        Name: "BMW",
    }
    car = bmw
    car.Run()
}

 //Golang中的接口，不需要显示的实现。只要一个变量，含有接口类型中的所有方法，那么这个变量就实现了这个接口。

//因此Golang中没有implement类似的关键字

//如果一个变量含有了多个interface类型的方法，那么这个变量就实现了多个接口

package main

import "fmt"

type Carer interface {
    GetName() string
    Run()
    DiDi()
}
type Test interface {
    Hello()
}

//宝马车
type BMW struct {
    Name string
}

//因此还得实现RUN()
//得实现接口所有的方法，才算实现了该接口
func (p *BMW) GetName() string {
    return p.Name
}

//实现接口的Run()
func (p *BMW) Run() {
    fmt.Printf("%s is running
", p.Name)
}

//还得实现DiDi()
func (p *BMW) DiDi() {
    fmt.Printf("%s is didi
", p.Name)
}

func (p *BMW) Hello() {
    fmt.Printf("hello,i'm %s 
", p.Name)
}

//比亚迪
type BYD struct {
    Name string
}

func (p *BYD) GetName() string {
    return p.Name
}

func (p *BYD) Run() {
    fmt.Printf("%s is running
", p.Name)
}
func (p *BYD) DiDi() {
    fmt.Printf("%s is didi
", p.Name)
}

func main() {
    var car Carer
    var test Test
    fmt.Println(car)
    //var bmw BMW
    //bmw.Name = "BMW"
    //写法2
    bmw := &BMW{
        Name: "BMW",
    }
    car = bmw
    car.Run()

    test = bmw
    test.Hello()

    byd := &BYD{
        Name: "BYD",
    }
    car = byd
    car.Run()
}

Golang之指针(point)再探索

package main

import "fmt"

/*
声明指针
*T 是指向类型T的值的指针变量的类型
*/

func main() {
    //b := 255
    //var a *int = &b // a是int指针，指向b的内存地址
    //fmt.Printf("Type of is：%T
", a)
    //fmt.Println("address of b is", a)
    //

    //a := 22
    //var b *int //b 这个变量是int类型的指针变量，变量的值，也只能是int型指针
    //if b == nil {
    //    // 指针的零值是nil
    //    fmt.Println("b is", b)
    //    b = &a
    //    fmt.Println("b after initialization is", b)
    //}

    //b := 255
    //a := &b
    //fmt.Println("address of b is", a)//打印b的内存地址
    //fmt.Println("value of b is", *a)//打印b的值，可以通过*a指针

    //b := 255
    //a := &b
    //fmt.Println("address of b is：", a) //b的内存地址
    //fmt.Println("value of b is:", *a)
    //*a++ //通过a的指针加一
    //fmt.Println("new value of b is:", b)

    //a := 58
    //fmt.Println("value of a befor func call is:", a)
    //b := &a
    //change(b) //指针变量b，改变a的值，a=55，
    //fmt.Println("value of a after call is:", a)

    /*
        不要将指向数组的指针，作为参数传递给函数，改用切片

    */
    //a := [3]int{89, 90, 91}
    //modify(&a) //传递数组a的地址，给modify
    //fmt.Println(a)

    a := [3]int{89, 90, 91}
    modify(a[:]) //传入一个a的切片
    fmt.Println(a)
}

//函数传递指针，改变参数的内存地址。
//func change(val *int) {
//    *val = 55

//修改数组的值
//传递指向数组的指针，作为参数，并且对其修改
//func modify(arr *[3]int) {
//    (*arr)[0] = 90
//    //arr[0]=90  //也可以这么写，这是上面的简写形式(*a)[X]可以写成a[X]
//}

//切片方式修改函数
//这个方法是修改函数最常用的，最好的方法。。。。。。。。。。。。
func modify(sls []int) {
    sls[0] = 91
}

//Go不支持如同C的指针运算

Golang之interface（多态，类型断言）

多态用法

package main

//一种事物的多种形态，都可以按照统一的接口进行操作
//多态
import (
    "fmt"
    "math/rand"
    "sort"
)

type Student struct {
    Name     string
    Id       string
    Age      int
    sortType int
}
type Book struct {
    Name   string
    Author string
}

//切片默认传地址
type StudentArray []Student

func (p StudentArray) Len() int {
    return len(p)
}

func (p StudentArray) Less(i, j int) bool {
    return p[i].Name < p[j].Name
}

func (p StudentArray) Swap(i, j int) {
    p[i], p[j] = p[j], p[i]
}

func main() {
    var stus StudentArray
    for i := 0; i < 10; i++ {
        stu := Student{
            Name: fmt.Sprintf("stu%d", rand.Intn(100)),
            Id:   fmt.Sprintf("110%d", rand.Int()),
            Age:  rand.Intn(100),
        }
        stus = append(stus, stu)
    }
    for _, v := range stus {
        fmt.Println(v)
    }

    fmt.Println("

")
    sort.Sort(stus)
    for _, v := range stus {
        fmt.Println(v)
    }
}

 接口嵌套

package main

import "fmt"
//接口嵌套 一个接口可以嵌套在另外的接口
type Reader interface {
    Read()
}
type Writer interface {
    Write()
}
type ReadWriter interface {
    Reader
    Writer
}
type File struct {
}

func (f *File) Read() {
    fmt.Println("read data")
}

func (f *File) Write() {
    fmt.Print("write data")
}
func Test(rw ReadWriter) {
    rw.Read()
    rw.Write()
}

func main() {
    var f File
    Test(&f)
}

 类型断言

package main

import "fmt"

type Student struct {
    Name string
    Sex  string
}
//类型断言
//一个判断传入参数类型的函数
func just(items ...interface{}) {
    for index, v := range items {
        switch v.(type) {
        case bool:
            fmt.Printf("%d params is bool,value is %v
", index, v)
        case int, int64, int32:
            fmt.Printf("%d params is int,value is %v
", index, v)
        case float32, float64:
            fmt.Printf("%d params is float,value is %v
", index, v)
        case string:
            fmt.Printf("%d params is string,value is %v
", index, v)
        case Student:
            fmt.Printf("%d params student,value is %v
", index, v)
        case *Student:
            fmt.Printf("%d params *student,value is %v
", index, v)

        }
    }
}
func main() {
    var b Student = Student{
        Name: "stu01",
        Sex:  "female",
    }
    just(28, 8.2, "this is a test", b, &b)

}

Golang之实现（链表）

链表算法

package main

import "fmt"

type LinkNode struct {
    data interface{}
    next *LinkNode
}
type Link struct {
    head *LinkNode
    tail *LinkNode
}

func (p *Link) InsertHead(data interface{}) {
    node := &LinkNode{
        data: data,
        next: nil,
    }
    if p.tail == nil && p.head == nil {
        p.tail = node
        p.head = node
        return
    }
}

func (p *Link) InsertTail(data interface{}) {
    node := &LinkNode{
        data: data,
        next: nil,
    }
    if p.tail == nil && p.head == nil {
        p.tail = node
        p.head = node
        return
    }
    p.tail.next = node
    p.tail = node
}
func (p *Link)Trans(){
    q:=p.head
    for q!=nil{
        fmt.Println(q.data)
        q=q.next
    }
}

package main

import "fmt"

func main() {

    var link Link
    for i := 0; i < 10; i++ {

        //link.InsertHead(i)
        link.InsertTail(fmt.Sprintf("str %d",i))
    }
    link.Trans()
}

Golang之反射（重点！！）

1、反射：可以在运行时动态获取变量的相关信息

Import（“reflect”）

两个函数：

reflect.TypeOf()//获取变量的类型，返回reflect.Type类型
reflect.ValueOf()//获取变量的值，返回reflect.Value类型
reflect.Value.Kind()//获取变量的类别，返回一个常量
reflect.Value.Interface()//转换成interface{}类型

可逆状态

示例用法

package main

import (
    "fmt"
    "reflect"
)

type Student struct {
    Name  string
    Age   int
    Score float32
}

func test(b interface{}) {
    t := reflect.TypeOf(b)
    fmt.Println(t)

    v := reflect.ValueOf(b)
    k := v.Kind()
    fmt.Println(k)

    iv := v.Interface()
    stu, ok := iv.(Student)
    if ok {
        fmt.Printf("%v %T
", stu, stu)
    }
}
func testInt(b interface{}) {
    val := reflect.ValueOf(b)
    c := val.Int()
    fmt.Printf("get value interface{} %d
", c)
}

func main() {
    var a Student = Student{
        Name:  "stu01",
        Age:   18,
        Score: 92,
    }
    test(a)
    testInt(1234)
}

package main

import (
    "fmt"
    "reflect"
)
func main(){
    var x float64=3.4
    fmt.Println("type:",reflect.TypeOf(x))

    v:=reflect.ValueOf(x)
    fmt.Println("value:",v)
    fmt.Println("type:",v.Type())
    fmt.Println("kind:",v.Kind())
    fmt.Println("value:",v.Float())

    fmt.Println(v.Interface())
    fmt.Printf("value is %5.2e
",v.Interface())
    y:=v.Interface().(float64)
    fmt.Println(y)
}

 获取变量的值

reflect.ValueOf(x).Float()
reflect.ValueOf(x).Int()
reflect.ValueOf(x).String()
reflect.ValueOf(x).Bool()

反射之elem()修改指针的方法

package main

//通过反射动态修改变量的值
import (
    "fmt"
    "reflect"
)

type Student struct {
    Name  string
    Age   int
    Score float32
}

func test(b interface{}) {
    t := reflect.TypeOf(b)
    fmt.Println(t)

    v := reflect.ValueOf(b)
    k := v.Kind()
    fmt.Println(k)

    iv := v.Interface()
    stu, ok := iv.(Student)
    if ok {
        fmt.Printf("%v %T
", stu, stu)
    }
}

func testInt(b interface{}) {
    val := reflect.ValueOf(b)
    val.Elem().SetInt(100) //val.Elem().Setint()相当于指针操作

    c := val.Elem().Int()
    fmt.Printf("get value interface{}%d
", c)
    fmt.Printf("string val:%d
", val.Elem().Int())
}
func main() {
    var a Student = Student{
        Name:  "stu01",
        Age:   18,
        Score: 92,
    }
    test(a)
    var b int = 1
    b = 200
    testInt(&b)
    fmt.Println(b)
}

 用反射操作结构体

reflect.Value.NumField()获取结构体中字段的个数
reflect.Value.Method(n).Call来条用结构体中的方法

反射取得结构体方法个数，字段数

package main

//通过反射动态修改变量的值
import (
    "fmt"
    "reflect"
)

type Student struct {
    Name  string
    Age   int
    Score float32
    Sex   string
}

func (s Student) Set(name string, age int, score float32, sex string) {
    s.Name = name
    s.Age = age
    s.Score = score
    s.Sex = sex
}

func TestStruct(a interface{}) {
    val := reflect.ValueOf(a)
    kd := val.Kind()
    if kd != reflect.Struct {
        fmt.Println("expect struct")
        return
    }
    num := val.NumField()
    fmt.Printf("struct has %d fields
", num)

    numOfMethod := val.NumMethod()
    fmt.Printf("struct has %d methods
", numOfMethod)
}

func main() {
    var a Student
    a = Student{
        Name:  "stu01",
        Age:   18,
        Score: 92.8,
    }
    TestStruct(a)
    fmt.Println(a)
}

 反射练习

package main

//通过反射动态修改变量的值
import (
    "fmt"
    "reflect"
)

type NotKnownType struct {
    s1 string
    s2 string
    s3 string
}

//定义一个String方法
func (n NotKnownType) String() string {
    return n.s1 + "-" + n.s2 + "-" + n.s3
}

var secret interface{} = NotKnownType{"Ada", "Go", "Oberon"}

func main() {
    value := reflect.ValueOf(secret) //<main.NotKnownType Value>
    typ := reflect.TypeOf(secret)    //main.NotKnownType
    fmt.Println(typ)
    knd := value.Kind() //struct
    fmt.Println(knd)
    for i := 0; i < value.NumField(); i++ {
        fmt.Printf("Field %d:%v
", i, value.Field(i))
    }
    results := value.Method(0).Call(nil)
    fmt.Println(results)//[Ada-Go-Oberon]
}

通过反射修改结构体

package main

import (
    "fmt"
    "reflect"
)

type T struct {
    A int
    B string
}

func main() {
    t := T{23, "skidoo"}
    s := reflect.ValueOf(&t).Elem()
    typeOfT := s.Type()
    for i := 0; i < s.NumField(); i++ {
        f := s.Field(i)
        fmt.Printf("%d:%s %s=%v
",
            i, typeOfT.Field(i).Name, f.Type(), f.Interface())
    }
    s.Field(0).SetInt(77)
    s.Field(1).SetString("Sunset Strip")
    fmt.Println("t is now", t)
}

Golang之实现一个负载均衡算法（随机，轮询）

代码记录

程序结构目录

--------程序包

package balance

type Balancer interface {
    DoBalance([]*Instance, ...string) (*Instance, error)
}

package balance

import (
    "strconv"
)

type Instance struct {
    host string
    port int
}

func NewInstance(host string, port int) *Instance {
    return &Instance{
        host: host,
        port: port,
    }
}

//定义Instance结构体的方法GetHost()
func (p *Instance) GetHost() string {
    return p.host
}

//定义方法GetPort()
func (p *Instance) GetPort() int {
    return p.port
}
func (p *Instance) String() string {
    return p.host + ":" + strconv.Itoa(p.port)
}

package balance

import "fmt"

type BalanceMgr struct {
    allBalancer map[string]Balancer
}

var mgr = BalanceMgr{
    allBalancer: make(map[string]Balancer),
}

func (p *BalanceMgr) registerBalancer(name string, b Balancer) {
    p.allBalancer[name] = b
}
func RegisterBalancer(name string, b Balancer) {
    mgr.registerBalancer(name, b)
}
func DoBalance(name string, insts []*Instance) (inst *Instance, err error) {
    balancer, ok := mgr.allBalancer[name]
    if !ok {
        err = fmt.Errorf("Not found %s balancer", name)
        return
    }
    fmt.Printf("use %s balancer
", name)
    inst, err = balancer.DoBalance(insts)
    return
}

package balance

import (
    "errors"
    "math/rand"
)

func init() {
    RegisterBalancer("random", &RandomBalance{})
}

type RandomBalance struct {
}

func (p *RandomBalance) DoBalance(insts []*Instance, key ...string) (inst *Instance, err error) {
    if len(insts) == 0 {
        err = errors.New("No instance")
        return
    }
    lens := len(insts)
    index := rand.Intn(lens)
    inst = insts[index]
    return
}

package balance

import (
    "errors"
)

func init() {
    RegisterBalancer("roundrobin", &RoundRobinBalance{})
}

type RoundRobinBalance struct {
    curIndex int
}

func (p *RoundRobinBalance) DoBalance(insts []*Instance, key ...string) (inst *Instance, err error) {
    if len(insts) == 0 {
        err = errors.New("No instance")
        return
    }
    lens := len(insts)
    if p.curIndex >= lens {
        p.curIndex = 0
    }
    inst = insts[p.curIndex]
    p.curIndex = (p.curIndex + 1) % lens
    return
}

------入口

package main

import (
    "fmt"
    "go_dev/day7/example/example1/balance"
    "math/rand"
    "os"
    "time"
)

func main() {
    var insts []*balance.Instance
    for i := 0; i < 16; i++ {
        host := fmt.Sprintf("192.168.%d.%d", rand.Intn(255), rand.Intn(255))
        one := balance.NewInstance(host, 8080)
        insts = append(insts, one)
    }
    var balanceName = "random"
    if len(os.Args) > 1 {
        balanceName = os.Args[1]
    }
    for {
        inst, err := balance.DoBalance(balanceName, insts)
        if err != nil {
            fmt.Println("do balance err:", err)
            fmt.Fprintf(os.Stdout, "do balance err
")
            continue
        }
        fmt.Println(inst)
        time.Sleep(time.Second)
    }
}

package main

import (
    "fmt"
    "go_dev/day7/example/example1/balance"
    "hash/crc32"
    "math/rand"
)

type HashBalance struct {
    Name string
    Age  int
}

func init() {
    balance.RegisterBalancer("hash", &HashBalance{})
}
func (p *HashBalance) DoBalance(insts []*balance.Instance, key ...string) (inst *balance.Instance, err error) {
    var defKey string = fmt.Sprintf("%d", rand.Int())
    if len(key) > 0 {
        defKey = key[0]
    }
    lens := len(insts)
    if lens == 0 {
        err = fmt.Errorf("No backend instance")
        return
    }
    crcTable := crc32.MakeTable(crc32.IEEE)
    hashVal := crc32.Checksum([]byte(defKey), crcTable)
    index := int(hashVal) % lens
    inst = insts[index]
    return
}