go语言初步了解

// myNote1 project main.go
package main

//go语言中提供不同的包，相当于java中不同的类，来提供功能
import (
    "fmt"
)

var ( // 这种因式分解关键字的写法一般用于声明全局变量
    aa int
    bb bool
)

func main() {
    //输出语句
    fmt.Println("Hello World!")

    //定义变量
    var i int
    i = 10
    var j = "jjjjjjjjjjjj"
    k := "kkkkkkkkkkk"
    fmt.Println("变量:", i)
    fmt.Println("变量:", j)
    fmt.Println("变量:", k)
    //定义多个变量
    var s, u, g int
    s, u, g = 10, 20, 30
    fmt.Println("变量:", s)
    fmt.Println("变量:", u)
    fmt.Println("变量:", g)

    var a, b, c = "aaa", "bbb", "ccc"
    fmt.Println("变量:", a)
    fmt.Println("变量:", b)
    fmt.Println("变量:", c)

    d, e, f := "ddd", "eee", "fff"
    fmt.Println("变量:", d)
    fmt.Println("变量:", e)
    fmt.Println("变量:", f)

    //全局变量
    fmt.Println("全局变量:", aa)
    fmt.Println("全局变量:", bb)

    //获取变量的内存地址
    fmt.Println("内存地址:", &a)

    //当申明了一个变量，但是却没有使用它，那么会报jj declared and not used
    //var jj string = "jk"

    //定义常量 编程习惯都是以大写字母来定义常量的
    //const 定义特定类型的常量
    const LEFT int = 100
    const RIGHT = 200
    const UP, DOWN = 300, 400
    const (
        BEFORE = 500
        AFTER  = 600
    )
    fmt.Println("常量:", LEFT, RIGHT, UP, DOWN, BEFORE, AFTER)

    //运算
    var v, z int = 10, 20

    fmt.Println("加法：", v+z)
    fmt.Println("减法：", v-z)
    fmt.Println("乘法：", v*z)
    fmt.Println("除法：", v/z)
    fmt.Println("取余：", v%z)
    fmt.Println("小于等于：", v <= z)
    fmt.Println("等于：", v == z)



    //if else elseif
    if 10 == 10 {
        fmt.Println("if语句")
    }

    if 10 == 20 {
        fmt.Println("if语句")
    } else {
        fmt.Println("else语句")
    }
    //switch
    jk := "a"
    switch jk {
    case "a":
        fmt.Println("分支语句")
        break
    case "b":
        fmt.Println("xxxxx")
        break
    default:
        fmt.Println("--------")
        break
    }


    var index = 1

    for index < 4 {
        fmt.Println("-------")
        index++
    }


    var flat int = 3
A:
    index = 1
    for index < 3 {
        fmt.Println("xxxx")
        index++
    }
    flat++
    if flat < 5 {
        goto A
    }


    testFun1()
    testFun2(10, 20)
    fmt.Println("函数返回：", testFun3(10, 20))
    x, y := testFun4(10, 20)
    fmt.Println("函数返回多个值：", x, y)


    var arr [3]int
    arr[0] = 1
    arr[1] = 10
    arr[2] = 32
    {
        var op int = 0
        for op < len(arr) {
            fmt.Println(arr[op])
            op++
        }

    }
    //不设置数组的大小
    var arr1 = [...]float64{12.12, 34.2, 45.2}
    fmt.Println(arr1)
    var arr2 = [5]float32{11.23, 343.23, 34.5}
    fmt.Println(arr2)

    //数据结构指针
    var in int = 100
    fmt.Println("变量的地址", &in)
    //定义指针 指向整数的指针
    var ini *int
    ini = &in
    fmt.Println("指针获取数据", *ini)
    //空指针
    var ink *int
    fmt.Println("判断空指针", (ink == nil))


    //数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。说白了就是java中的一个类，用于创建对象的一个模板
    type Book struct {
        title string
        num   int
        names []float32
        flag  bool
    }
    var book1 Book
    book1.flag = true
    book1.num = 10
    book1.title = "曹雪坤"
    book1.names = []float32{1000.0, 2.0, 3.4, 7.0, 50.0}
    fmt.Println(book1)


    //Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，
    //功能强悍的内置类型切片("动态数组"),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。
    //说白了就是java中的集合

    //切片利用make创建：T 代表被创建的切片元素的类型。
    //函数 make 接受一个类型、一个长度（创建切片时的初始化长度）和一个可选的容量参数。调用 make 时，内部会分配一个数组，然后返回数组对应的切片。
    //var numbers []int = make([]int, 5, 5)

    numbers := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}

    fmt.Println(numbers)
    fmt.Println("numbers[1:4] ==", numbers[1:4])
    /* 默认下限为 0*/
    fmt.Println("numbers[:3] ==", numbers[:3])
    /* 默认上限为 len(s)*/
    fmt.Println("numbers[4:] ==", numbers[4:])
    fmt.Println("计算切片的容量：", cap(numbers))
    fmt.Println("计算切片的长度：", len(numbers))

    numbers = append(numbers, 13)
    fmt.Println("追加元素后：", numbers)

    //删除下标为9的元素
    numbers = append(numbers[:9], numbers[10:]...)
    fmt.Println("删除指定位置的元素后：", numbers)

    //删除切片的最后一个元素
    numbers = append(numbers[:len(numbers)-1], numbers[len(numbers):]...)
    fmt.Println("删除切片的最后一个元素：", numbers)

    fmt.Println("计算切片的长度：", len(numbers))

    var number1 []int
    if number1 == nil {
        fmt.Println("切片是空的")
    }


    //创建map
    var countryCapitalMap map[string]string
    /* 创建集合 */
    countryCapitalMap = make(map[string]string)

    /* map 插入 key-value 对，各个国家对应的首都 */
    countryCapitalMap["France"] = "Paris"
    countryCapitalMap["Italy"] = "Rome"
    countryCapitalMap["Japan"] = "Tokyo"
    countryCapitalMap["India"] = "New Delhi"

    fmt.Println(countryCapitalMap["India"])

    /* 使用 key 输出 map 值 */
    for country := range countryCapitalMap {
        fmt.Println("Capital of", country, "is", countryCapitalMap[country])
    }

    /* 查看元素在集合中是否存在 */
    captial, ok := countryCapitalMap["India"]
    /* 如果 ok 是 true, 则存在，否则不存在 */
    if ok {
        fmt.Println("Capital of India is----", captial)
    } else {
        fmt.Println("Capital of United States is not present")
    }


    //实现两个结构体
    var phone Phone
    phone = new(IPhone)
    phone.call()

    phone = new(XiaoMi)
    phone.call()
}

//函数
func testFun1() {
    fmt.Println("函数")
}

func testFun2(num1 int, num2 int) {
    fmt.Println("函数参数", num1+num2)
}

//函数返回单个值
func testFun3(num1 int, num2 int) int {
    return num1 + num2
}

//函数返回多个值
func testFun4(num1 int, num2 int) (int, int) {
    return num1 + num2, num1 - num2
}

//定义接口 利用不同的结构体创建继承该接口的不同的方法
type Phone interface {
    //接口中的方法
    call()
}

//定义结构体
type IPhone struct{}

//定义接口中的方法
func (iphone IPhone) call() {
    fmt.Println("你用的手机是苹果")
}

//定义另一个结构体
type XiaoMi struct{}

//定义接口中的方法
func (xiaoMi XiaoMi) call() {
    fmt.Println("你用的手机是小米: ")
}