GO语言（六）接口使用

<music>

　　|------<src>

　　　　　　 |-------<library>

　　　　　　　　　　　　|-------manager.go

　　　　　　　　　　　　|-------manager_test.go

　　　　　　 |-------<play>

　　　　　　　　　　　　|-------play.go

　　　　　　　　　　　　|-------mp3.go

　　　　　　　　　　　　|-------wav.go

　　　　　　 |--------<music>

　　　　　　　　　　　　|-------mplayer.go

　　|------<pkg>

　　|------<bin>

------------------------------------------------------------------------------------

library：音乐库文件所在目录

[manager.go]

package  library

import "errors"

type MusicEntry struct {
  Id string
  Name string
  Artist string
  Source string
  Type string
}

type MusicManager struct {
  musics []MusicEntry
}

func NewMusicManager() *MusicManager {
  return &MusicManager{make([]MusicEntry, 0)} 
}

func (m *MusicManager) Len() int {
  return len(m.musics)
}

func (m *MusicManager) Get(index int) (music *MusicEntry, err error) {
  if index <0 || index >= len(m.musics) {
    return nil, errors.New("Index out of range.")
  }
  return &m.musics[index], nil 
}

func (m *MusicManager) Find(name string) *MusicEntry {
  if len(m.musics)==0 {
    return nil 
  }

  for _,mm := range m.musics {
    if mm.Name == name {
      return &mm 
    }  
  }
  return nil
}

func (m *MusicManager)Add(music *MusicEntry) {
  m.musics = append(m.musics, *music)
}

func (m *MusicManager)Remove(index int) *MusicEntry {
  if index<0 || index >= len(m.musics) {
    return nil
  }

  removedMusic := &m.musics[index]

  if index < len(m.musics)-1 {
    m.musics = append(m.musics[:index-1], m.musics[index+1:]...)
  } else if index ==0 {
    m.musics = make([]MusicEntry, 0)
  }else {
    m.musics = m.musics[:index-1]
  }
  return removedMusic
}

[manager_test.go]

package library

import (
  "testing"
)

func TestOps(t *testing.T) {
  mm := NewMusicManager()
  if mm == nil {
    t.Error("NewMusicManager() failed.")
  }
  m0 := &MusicEntry {"1", "Cellion Dion", "My Heart Will Go On", "http://qbox.me/24501234", "MP3" }
  mm.Add(m0)

  if mm.Len() != 1 { 
    t.Error("MusicManager.Add() failed.")
  }

  m := mm.Find(m0.Name)

  if m == nil {
    t.Error("MusicManager.Find() failed.")
  }

  if m.Id != m0.Id || m.Artist != m0.Artist || m.Name != m0.Name || m.Source != m0.Source || m.Type != m0.Type {
    t.Error("MusicManager.Find() failed. Found item mismatch.")
  }

  m, err := mm.Get(0)

  if m == nil {
    t.Error("MusicManager.Get() failed.", err)
  }

  m = mm.Remove(0)
  if m == nil || mm.Len() != 0 { 
    t.Error("MusicManager.Remove() failed.", err)
  }
}

play：各种音乐类型存放库

[play.go]

package play

import "fmt"

type Player interface {
  Play(source string)
}

func Play(source, mtype string) {
  var p Player
  switch mtype {
    case "MP3":
      p = &MP3Player{}
    case "WAV":
      p = &WAVPlayer{}
    default:
      fmt.Println("Unsupported music type", mtype)
      return
  }
  p.Play(source)
}

[mp3.go]

package play

import (
  "fmt"
  "time"
)

type MP3Player struct {
  stat int 
  progress int 
}

func (p *MP3Player)Play(source string) {
  fmt.Println("Playing MP3 music", source)

  p.progress = 0 

  for p.progress < 100 {
    time.Sleep(100*time.Millisecond)
    fmt.Print(".")
    p.progress += 1
  }

  fmt.Println("
Finished playing", source)
}

[wav.go]

package play

import (
  "fmt"
  "time"
)

type WAVPlayer struct {
  stat int 
  progress int 
}

func (p *WAVPlayer) Play(source string) {
  fmt.Println("Playing WAV music", source)

  p.progress = 0 

  for p.progress < 100 {
    time.Sleep(1000*time.Millisecond)
    fmt.Print(".")
    p.progress += 10
  }

  fmt.Println("
Finished playing", source)
}

music：主程序的放在处

[mplayer.go]

package main

import  (
  "bufio"
  "fmt"
  "os"
  "strconv"
  "strings"
  "play"
  "library"
)

var lib *library.MusicManager
var id int = 1
var ctrl, signal chan int

func handleLibCommands(tokens []string) {
  switch tokens[1] {
    case "list" :
      for i:=0; i<lib.Len(); i++ {
        e,_ := lib.Get(i)
        fmt.Println(i+1, ":", e.Name, e.Artist, e.Source, e.Type)
      }   
    case "add":
      if len(tokens) == 6 { 
        id++
        lib.Add(&library.MusicEntry{string(strconv.Itoa(id)),tokens[2],tokens[3],tokens[4],tokens[5]})
      }else {
        fmt.Println("USAGE: library add <name><artist><source><type>")
      }   
    case "remove":
      if len(tokens) == 3 { 
        lib.Remove(3) // 有问题
      } else {
        fmt.Println("USAGE: library remove <name>")
      }   
    default:
      fmt.Println("Unrecongnized library command:", tokens[1])
  }
}

func handlePlayCommands(tokens []string) {
  if len(tokens) != 2 {
    fmt.Println("USAGE: play <name>")
    return
  }

  e := lib.Find(tokens[1])

  if e == nil {
    fmt.Println("The music", tokens[1], "does not exist.")
    return
  }

  play.Play(e.Source, e.Type)
}

func main() {
  fmt.Println(`
    Enter following commands to control the player:
    lib add <name><artist><source><type>
    lib remove <name>
    play <name>
  `)

  lib = library.NewMusicManager()

  r := bufio.NewReader(os.Stdin)

  for {
    fmt.Println("Enter command->")

    rawLine,_,_ := r.ReadLine()

    line := string(rawLine)

    if line == "q" || line == "e" {
       break
    }

    tokens := strings.Split(line, " ")

    if  tokens[0] == "lib" {
      handleLibCommands(tokens)
    }else if tokens[0] == "play" {
      handlePlayCommands(tokens)
    }else {
      fmt.Println("Unrecongnized command:", tokens[0])
    }
  }
}

；之后，返回到music目录节点，执行如下命令：

go build library

go build play

go build music

go test library

go install library

go install play

go install music

--------------------------------------------------------------------

接口使用的感受：

　　1、类似于C++中虚基类的作用，作为一个消费者的接口，用于接收生产者设计的方法；

　　2、生产者设计也简单，只需要实现接口中的方法就算设计了接口【无需如C++的，还需要继承】；

　　3、使用简单，设计也简单；