go 学习-2

1、package的创建
//自定义包配置文件，在家目录 .profile文件里面

$GOROOT

$GOPATH

【1】import 首先会去$GOROOT/src 里面找包，一般的标准包都在这个文件夹里面

【2】然后会去$GOPATH/src里面找包(包名就是文件夹)，我们自己写的包就放在这个文件夹下，在这个文件夹里面写.go文件就可以了
//有个init函数，会被自动调用，这个是初始化函数（如果把包导入项目中，这个函数会自动调用），包中的函数，首字母必须大写才能被用户使用
【3】如何使用，在使用的.go文件里面 import testpack ，调用函数就可以了

package main

import "testpack"
import "fmt"

//自定义包

func main() {
    //testpack.Tnit()
    testpack.Test()
}

2、结构体绑定函数

package main

import "fmt"

type Maker struct {
    Name string //成员函数首字母大写  表示公有成员
    age  int    // 私用成员
}

// 结构体绑定函数  值传递
func (this Maker) setAge(age int) {
    this.age = age

}

// 结构体绑定函数  地址传递
func (this *Maker) setAge1(age int) {
    this.age = age

}

func main() {
    var maker = Maker{Name: "小6", age: 19}
    maker.setAge(1)
    fmt.Println(maker)
    fmt.Println("----------------------")
    maker.setAge1(100)
    fmt.Println(maker)
}

3、继承

package main

import "fmt"

type Maker struct {
    name string
    age  int
    sex  string
}

type SonMaker struct {
    Maker
    name string
    age  int
}

// 结构体绑定成员函数
func (this *Maker) gotoScool() {
    fmt.Println("上学")
}

// 结构体绑定成员函数
func (this *SonMaker) gotoScool() {
    fmt.Println("son上学")
}


func main() {
    //var myma Maker
    //结构体初始化
    var mymaker = Maker{"xx", 22, "sss"}               //-------1
    var maker = Maker{name: "父类", age: 33, sex: "nan"} //-----2
    //var son = SonMaker{myma, "xxxx", 10}
    var son = SonMaker{mymaker, "xxxx", 10}
    fmt.Println(maker)
    maker.gotoScool()
    fmt.Println("----------")
    fmt.Println(son)
    son.gotoScool()

}

4、多态

package main

import "fmt"

//interface是万能数据类型
type InterFc interface {
    getSomething()
}

//只需要重写父类的函数
func (this *Maker) getSomething() {
    fmt.Println("Maker这是接口")
}

//只需要重写父类的函数
func (this *Son) getSomething() {
    fmt.Println("Son这是接口")
}

type Maker struct {
    name string
    age  int
}

type Son struct {
    name string
    age  int
}

//业务
func mytest(an InterFc) {
    an.getSomething()
}

func main() {
    var it InterFc
    it = &Maker{"myMaker", 22}
    it.getSomething()
    mytest(it)

    fmt.Println("------------")
    it = &Son{"myMaker", 22}
    it.getSomething()

}

5、万能型数据类型

package main

import "fmt"

//interface 是万能数据类型

func myfunc(arg interface{}) {
    fmt.Println("....myfunc...")
    value, ok := arg.(string) //这个函数返回2个值，一个是value 一个是判断这个类型是否正确
    if !ok {
        fmt.Println("这个不是string类型")
        return
    }
    fmt.Println(value)
}

func main() {
    myfunc("xxxx")
}

6、工厂模式

package main

import "fmt"

type Animal interface {
    Sleep()
}

type Dog struct {
    age int
}

type Cat struct {
    name string
}

func (this *Cat) Sleep() {
    fmt.Println("cat ...")
}
func (this Dog) Sleep() {
    fmt.Println("Dog ...")
}

// 父对象接收 子对象  发生多态

//创建一个工厂
func CreateAnimal(name string) Animal {
    switch name {
    case "dog":
        return &Dog{20}
    case "cat":
        return &Cat{"xxxx"}
    default:
        return nil
    }
}

func main() {

    ret := CreateAnimal("xx")
    fmt.Println(ret)
}

7、切片 make切片就是一个连续的内存空间的首地址
s := []int{1, 2, 3} //定义了一个切片
s1 := make([]int, 3) //开辟了一个空间，空间大小为3个int

package main

import "fmt"

//import "reflect"

func main() {

    //和数组没啥区别
    //切片就是一个连续的内存空间的首地址
    s := []int{1, 2, 3}  //定义了一个切片
    s1 := make([]int, 3) //开辟了一个空间，空间大小为3个int

    //长度和容量
    fmt.Println("s len", len(s), "s cap(s)", cap(s))
    fmt.Println("s1 len", len(s1), "s cap(s1)", cap(s1))

    //赋值
    s[0] = 1
    s[1] = 2
    s[2] = 3

    //动态扩容
    s = append(s, 4)
    s = append(s, 5) //让第五个元素为5

    //遍历
    for i := 0; i < len(s); i++ {
        fmt.Println(s[i])
    }

    //左开右闭原则[:]
    fmt.Println(s[1:3]) //下标从0开始---2 3，从下标为1的位置到3的位置但是不包括3
    fmt.Println(s[1:])  //2 3 4 5 从下标1的位置到最后的位置

    //注意  不是深拷贝，没有集合的复制，只是把s的地址传递给s2
    s2 := s[2:]
    fmt.Println("s2=", s2)
    //修改s s2也改变了
    s2[0] = 100
    fmt.Println("s=", s)
    fmt.Println("---------")

    s_new := make([]int, 3) //开辟一个切片  通过拷贝，可以复制集合
    copy(s_new, s[2:])      //如果数据不够，后面拷贝的数据就为0
    fmt.Println(s_new)
    s[4] = 999
    fmt.Println(s_new)

}

8、文件读写

package main

import (
    "fmt"
    "os"
)

//写文件
func test_write(filename string) {
    //1.打开文件
    file, err := os.Create(filename)
    //判断是否打开文
    if err != nil {

        fmt.Println(err)
        return
    }

    //3关闭文件
    defer file.Close()

    for i := 0; i < 10; i++ {
        outstr := fmt.Sprintf("%s:%d\n", "hello go", i)
        file.WriteString(outstr)
    }

}

func test_Read(filename string) {
    file, err := os.Open(filename)
    if err != nil {
        fmt.Println(err)
        return
    }

    defer file.Close()

    //开辟空间
    buf := make([]byte, 1024)

    for {
        num, _ := file.Read(buf)
        if num == 0 {
            break
        }
        os.Stdout.Write(buf)
    }

}

func main() {
    test_write("./a.txt")
    test_Read("./a.txt")
}

9、http请求

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func httpGet(url string) (conter string, statusCode int) {
    resp, err := http.Get(url)
    if err != nil {
        fmt.Println(err)
        conter = "网络请求错误"
        statusCode = -1
        return
    }

    //读取数据
    data, err := ioutil.ReadAll(resp.Body)
    if err != nil {

        statusCode = -2
        conter = "解析数据失败"
        return
    }

    conter = string(data) //把数据转换为string

    statusCode = resp.StatusCode
    defer resp.Body.Close()

    return

}

func main() {

    data, code := httpGet("http://www.baidu.com")

    fmt.Println(data)
    fmt.Println(code)
}