https://mp.weixin.qq.com/s/kXahvVZPzCVLwRNd0jIJaQ

package main
import "fmt"

func main() {
  var msg string = "Hello World"  // 这里
  fmt.Print(msg)
}

类型 在变量名后边

也可不显式声明类型, 类型推断, 但是是静态语言, name一开始放字符串就不能再赋值数字

name := "lisa"
age := 30
msg := "hello"

用户自定义类型

方法,属性 分开 方法名首字母大写就是就是外部可调的

type User struct {
  name string
  age int
  email string
}

func (u User) sayHello() {
  fmt.Printf("Hi,I'm %s\n",u.name)
}

没有继承,只有组合

面向对象设计的一个重要原则：“优先使用组合而不是继承”
Dog 也是Animal , 要复用Animal 的属性和方法,
只需要在结构体type 里面写 Animal

type Animal struct {
  name string
  color string
}

func (a Animal) eat(){
  fmt.Printf("%s is eating\n",a.name)
}

type Dog struct {
  Animal  //这里
  welght int
}

入口也是main, 用用试试

func main() {
  animal :: Animal{"tom","black"}
  dog :: Dog{ animal ,19}

  fmt.Printf(dog.name)//tom

//都一样 输出Tom is eating
  dog.Animal.eat()
  dog.eat()

鸭子类型

多态, 有这个方法就是这个接口的实现, 具体的类 不需要知道自己实现了什么接口,

// 只要是能吃的 就是动物
type Animal interface
  eat()
}

type Dog struct {
  weight int
}
func (d *Dog) eat() { //能吃就是动物  狗不需要知道自己的动物
  fmt.Printf("Dog is eating\n")
}

type Cat struct {
  weight int
}
func (a *Cat) eat() { //猫也能吃 是动物
  fmt.Pnintf("Cat is eating\n")
}

轻量级的线程 goroutine

自己实现了一个线程的调度器:用户空间实现的线程， 非常地轻量级，所需的空间非常小，切换也发生在用户空间，开销极小。所以非常适合创建大量的goroutine去并发地执行请求。

使用: 在一个函数调用之前加上关键字go 就启动了一个goroutine

func main() {
  go sayHello()
  go sayHello()
}

创建一个goroutine,它会被加入到一个全局的运行队列当中，
调度器会把他们分配给某个逻辑处理器的队列，
一个逻辑处理器 绑定到一个操作系统线程，在上面运行goroutine，

如果goroutine需要读写文件, 阻塞 ,就脱离逻辑处理器 直接 goroutine - 系统线程 绑定

goroutine 之间通信:
通过Channel,一个通道，通过它各个goroutine就可以发送、接收数据了

直接生成exe执行

编译成同名.exe 来执行, 不通过虚拟机, 直接是机器码, 和C 一样, 所以非常快

但是也有自动垃圾回收,每个exe文件当中已经包含了一个类似于虚拟机的runtime,进行goroutine的调度

默认是静态链接的，那个exe会把运行时所需要的所有东西都加进去，这样就可以把exe复制到任何地方去运行了, 因此 生成的 .exe 文件非常大

框内就是exe, 很大