一.介面
1.介面

type Humaner interface {
   //方法，只有宣告，沒有實現，有別的型別實現
   sayhi()
}

type Student struct {
   name string
   id int
}
//Student實現了此方法
func (tmp *Student) sayhi(){
   fmt.Printf("Student[%s, %d] sayhi\n", tmp.name, tmp.id)
}

type Teacher struct {
   addr string
   group string
}

//Teacher實現了此方法
func (tmp *Teacher) sayhi() {
   fmt.Printf("Teacher[%s, %s] sayhi\n", tmp.addr, tmp.group)
}

//Mystr實現了此方法
type MyStr string
func (tmp MyStr) sayhi() {
   fmt.Printf("MyStr[%s] sayhi\n", tmp)
}

func WhoSayHi(i Humaner){
   i.sayhi()
}
//定義一個普通函式，函式的引數為介面型別
//只有一個函式，可以有不同表現形態，多型
func main(){
   s := &Student{"mike", 666}
}

func main01(){
    //定義介面型別變數
    //var i Humaner
    is := []Humaner{&Student{"mike", 666}, &Teacher{"bj", "go"}, MyStr("hello mike")}
    for _, human := range is{
       human.sayhi()
    }
    //只要實現了此介面方法的型別，那麼這個型別的變數（接受者的型別）就可以給i賦值
    //s := &Student{"mike", 666}
    //i = s
    //i.sayhi()
    //
    //t := &Teacher{"bj", "go"}
    //i = t
    //i.sayhi()
    //
    //var str MyStr = "hello mike"
    //i = &str
    //i.sayhi()

}
 

2.介面繼承

type Humaner interface {
   //方法，只有宣告，沒有實現，有別的型別實現
   sayhi()
}

type Personer interface {
   Humaner //匿名函式，繼承了sayhi()
   sing(lrc string)
}
type Student struct{
   name string
   id int
}
func (tmp *Student) sayhi() {
   fmt.Printf("%s : %d\n", tmp.name, tmp.id)
}
func (tmp *Student) sing(lrc string) {
   fmt.Println("Student is singing", lrc)
}
func main(){
   var i Personer
   s := &Student{"mike", 666}
   i = s
   i.sayhi()
   i.sing("學生2222")
}
 

3.空介面
//空介面不包含任何的方法，正因為如此，所有的型別都實現了空介面
//因此空介面可以儲存任意型別的數值

4.error函式
二.並行與併發
1.定義：
並行：多個程序使用多個cpu
併發：多個程序採用時間片輪轉的方法使用單個cpu
2.goroutine

• 建立

func newtask(){
   for {
      fmt.Println("this is anewTask")
      time.Sleep(time.Second)  //延時1s
   }
}
func main(){
   go newtask() //新建一個協程,新建一個任務

   for {
      fmt.Println("this is a main goroutine")
      time.Sleep(time.Second)  //延時1s
   }
}
 

• 主協程退出了，其他子協程也要跟著退出

func main(){
   go func() {
      i := 0
      for {
         i++
         fmt.Println("子協程 i = ", i)
         time.Sleep(time.Second)

      }
   }()
   i := 0
   for {
     i++
     fmt.Println("main i = ", i)
     time.Sleep(time.Second)

     if i==2{
        break
     }
   }

}

• runtime.Gosched()讓出時間片，先讓別的協議執行，它執行完，再回來執行此協程

func main(){
  go func() {
     for  i := 0; i < 5; i++ {
        fmt.Println("go")
     }
  }()

  for i := 0; i < 2; i++{
     //讓出時間片，先讓別的協議執行，它執行完，再回來執行此協程
     runtime.Gosched()
     fmt.Println("hello")
  }

}