Go语言基础快速上手_代码007(未授权)

本文介绍: Go中没有明确意思上的enum（枚举）定义，不过可以借用iota标识符实现一组自增常亮值来实现枚举类型。`切片(slice)`本身不是动态数组或动态指针。只是它内部采用数组存储数据，当数组长度达到数组容量时，会进行`动态扩容`。大白话就是切片功能和Java中的List集合类似，`动态添加数据`。不像数组(array)长度是固定的，需要事先知道数据长度。

在这里插入图片描述

Go中没有明确意思上的enum（枚举）定义，不过可以借用iota标识符实现一组自增常亮值来实现枚举类型。

const (
  a = iota // 0
  b        // 1
  c = 100  // 100
  d        // 100 (与上一行常量值表达式一致)
  e = iota // 4 (恢复iota自增，计数包括c、d)
  f        // 5
)

arr3 := [4]int{5, 3:10} // 可指定索引位置初始化
  fmt.Println(arr3) // [5 0 0 10]
  
arr4 := [...]int{1,2,3} // 编译器按照初始化值数量确定数组长度
  fmt.Println(arr4) // [1 2 3]

切片(slice)本身不是动态数组或动态指针。只是它内部采用数组存储数据，当数组长度达到数组容量时，会进行动态扩容。

大白话就是切片功能和Java中的List集合类似，动态添加数据。不像数组(array)长度是固定的，需要事先知道数据长度。

// 方式一
    a := make([]int,5) // 初始化长度为5的slice,默认值为零
    for i := 0; i <5; i++ {
       a = append(a, i)
    }
    a = append(a, 6)
    fmt.Println(a) // [0 0 0 0 0 0 1 2 3 4 6] 


    // 方式二    
    var a []int
    for i := 0; i < 5; i++ {
       a = append(a, i)
    }
    fmt.Println(a) // [0 1 2 3 4]

// 定义 变量strMap
   var strMap map[int]string
   // 进行初始化
   strMap = make(map[int]string)
   
   // 给map 赋值
   for i := 0; i < 5; i++ {
      strMap[i]  = "迈莫coding"
   }
   
   // 打印出map值
   for k, v := range strMap{
      fmt.Println(k, ":", v)
   }
  
  // 打印出map 长度
  fmt.Println(len(strMap))

type user struct {
   name string
   age  int
}

// 结构体user Read方法
func (u *user) Read() string {
   return fmt.Sprintf("%s 已经 %d 岁了", u.name, u.age)
}

func main() {
   // 初始化
   u := &user{
      name: "迈莫coding",
      age:  1,
   }
   fmt.Println(u.name, "已经", u.age, "岁了")
   // 调用结构体user的 Read方法
   fmt.Println(u.Read()) // 迈莫coding 已经 1 岁

接口是一组方法的集合

// 定义接口 包含公共方法
type user interface{
  talking()
}

// 定义一个struct类
type memo struct{
}

// 实现接口user中方法talking，非侵入式
func (m *memo) talking() {
  fmt.Println("迈莫coding欢迎您...")
}

func main() {
  mm := memo{}
  mm.talking

空接口没有任何办法，任何类型都无需实现空接口，空接口类型可以保存任何值，也可以从空接口中取出原值,在需要使用的地方使用。本身为nil。

type A interface{

}

{
    var a A
    fmt.Printf("%T", a) // nil
    
    a = 3
    a= "hello"
    
    fmt.Printf("%T", a) // String
}

如果我们反向想要知道这个接口变量里面实际存储的是哪个类型的对象，可以使用断言->对类型进行转换来判断类型。

package main
import（
    "fmt"
）
type Animal interface {
    Eat()
    Talk()
}
type Dog struct {

}
func (d *Dog) Eat(){
    fmt.Println("dog eating.....")
}
func (d *Dog) Talk(){
    fmt.Println("dog talking....")
}

type Cat struct {

}
func (c*Cat) Eat(){
    fmt.Println("cat eating.....")
}
func (c *Cat) Talk(){
    fmt.PrintIn("cat talking....")
}
func justify(a Animal){
//进行强制转换，如果转换失败则提示错误
    dog,ok := a.(*Dog)
    if !ok{
        fmt.Println("convert to dog failed")
        return
    }
    dog.Eat()
}

func main() {
// 分别实例化一个Dog和Cat,并通过justify来进行判断
    d := &Dog
    var a Animal
    a=d
    a.Eat()
    justify(a)
    
    c := &Cat{}
    a = c
    justify(a)
}