Golang 学习入坑，四Go语言数组/切片/结构体/指针/Range(范围/interface(接口

（一）数组

//数组定义：var variable_name [SIZE] variable_type
var arr [10] int
//以上为一维数组的定义方式。例如以下定义了数组 arr 长度为 10 类型为int：
//初始化数组：
var b = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
//初始化数组中 {} 中的元素个数不能大于 [] 中的数字。如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：
b := []float32{1000.0, 2.0, 3.4, 7.0, 50.0}

（二）切片

定义：Go 语言切片是对数组的抽象。
Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片("动态数组"),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。
//你可以声明一个未指定大小的数组来定义切片：
var identifier []type
使用make函数定义切片。或使用make()函数来创建切片:   
var slice1 []type = make([]type, len) 简写为：slice1 := make([]type, len)
其中len代表长度，cap代表最长多少  例如：make([]T, length, capacity)
// 创建一个整型切片其长度和容量都是 10 个元素
slice := make([]int, 10)
创建一个整型切片其长度为 3 个元素，容量为 5 个元素
slice := make([]int, 3, 5)
//下边这个函数可以打印切片
func printfslic(x [] int) {
　　fmt.Printf("切片的长度为%d,最大为%d,slice为%v。。第二个参数为：%d\n",len(x),cap(x),x)
}
//其中nil切片/空切片。切片扩容。/切片赋值-限制切片容量
具体以后整理下：
现在看下这个自己打印下。https://www.cnblogs.com/sparkdev/p/10704614.html

(三)结构体

Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。
结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下：
type struct_variable_type struct {
   member definition
   member definition
   ...
   member definition
}
一旦定义了结构体类型，它就能用于变量的声明，语法格式如下
variable_name := structure_variable_type {value1, value2...valuen}
或
variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}

例子：
package main

import "fmt"

type person struct{
    name string
    age int
    ismarry bool
}

func main() {
    tongtong := person{"张tongtong",25,false}
    fmt.Println(tongtong)
    tongtong1 := person{name:"张tongtong",age:27,ismarry:true}
    fmt.Println(tongtong1)
}

(四)指针

Go 语言中指针是很容易学习的，Go 语言中使用指针可以更简单的执行一些任务。
Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。

package main
import "fmt"

func main() {
   a := 10
   fmt.Printf("变量的地址: %x\n", &a  )          //打印出来a变量的地址
}
什么是指针？一个指针变量指向了一个值的内存地址。类似于变量和常量，在使用指针前你需要声明指针。指针声明格式如下：
--在指针类型前面加上 * 号（前缀）来获取指针所指向的内容。--
var var_name *var-type
func main() {
        //var ip *int        // 指向整型的空指针
        //var fp *float32    // 指向浮点型的空指针

        a := 10
        var ip *int                      //定义一个指针变量

        ip = &a                              //指向a的内存地址
        fmt.Printf("a 变量的地址是: %x\n", &a  )

    /* 指针变量的存储地址 */
    fmt.Printf("ip 变量储存的指针地址: %x\n", ip )

    /* 使用指针访问值 */
    fmt.Printf("*ip 变量的值: %d\n", *ip )
}
//结果为
a 变量的地址是: c000014078
ip 变量储存的指针地址: c000014078
*ip 变量的值: 10

(五)范围range

package main

import "fmt"

type person struct{
    name string
    age int
    ismarry bool
}

func main() {
    numSlice := []int{1,3,2,3}
    nums := 0
    for _,val := range numSlice {
        nums += val
    }
    fmt.Println("nums:", nums)
    //这个是index
    for i, num := range numSlice {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }
    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }
    //range也可以用来枚举Unicode字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。
    for i, c := range "go" {
        fmt.Println(i, c)
    }


}

（六）接口

1. 什么是interface接口

　　interface 是GO语言的基础特性之一。可以理解为一种类型的规范或者约定。它跟java，C# 不太一样，不需要显示说明实现了某个接口，它没有继承或子类或“implements”关键字，只是通过约定的形式，隐式的实现interface 中的方法即可。因此，Golang 中的 interface 让编码更灵活、易扩展。

　　如何理解go 语言中的interface ？ 只需记住以下三点即可：

　　　　1. interface 是方法声明的集合

　　　　2. 任何类型的对象实现了在interface 接口中声明的全部方法，则表明该类型实现了该接口。

　　　　3. interface 可以作为一种数据类型，实现了该接口的任何对象都可以给对应的接口类型变量赋值。

注意：

　　a. interface 可以被任意对象实现，一个类型/对象也可以实现多个 interface

　　b. 方法不能重载，如 eat() eat(s string) 不能同时存在

package main

import "fmt"

type Person interface {
        car()
}
type Women struct{}

func (women Women) car() {
        fmt.Println("女人开车")
}

type Man struct{}

func (man Man) car() {
        fmt.Println("男人开车")
}

func main() {
        var person Person
        person = new(Women)
        person.car()
        person = new(Man)
        person.car()
}