2.go程序设计笔记(四)接口

go

go无需声明实现了哪些接口,只要提供接口的实现方法,必须实现接口里面的全部方法,才是实现了这个接口,下面看看一个接口的简单定义和实现

//定义一个接口
type MyRead interface {
	ReadImp([]byte) (int,error)
}
//再次定义一个接口
type MyWrite interface {
	WriteImp(w io.Writer) (int ,error)
}

//接口的继承
type MyReadWrite interface {
	MyRead
	MyWrite
}

//接口的实现 只要实现了接口的全部方法就实现了这个接口
type ReadWriteImp struct {

}
func (r *ReadWriteImp) ReadImp([]byte) (int,error)  {
	fmt.Print("我就是一个°方法")
	return 1,nil;
}

func (r *ReadWriteImp) WriteImp(w io.Writer) (int,error)  {
	fmt.Println("我就是一个写方法")
	return 1,nil
}
func (r *ReadWriteImp) Hello()  {
	fmt.Println("接口自己的方法")
}

下面我们来看看fmt中使用接口的范例

//os.write接口
type Writer interface {
	Write(p []byte) (n int, err error)
}

//os.Stdout
func NewFile(fd uintptr, name string) *File {
	h := syscall.Handle(fd)
	if h == syscall.InvalidHandle {
		return nil
	}
	return newFile(h, name, "file")
}


func Fprint(w io.Writer, a ...interface{}) (n int, err error) {
	p := newPrinter()
	p.doPrint(a)
	n, err = w.Write(p.buf)
	p.free()
	return
}

func Print(a ...interface{}) (n int, err error) {
	return Fprint(os.Stdout, a...)
}

func Sprint(a ...interface{}) string {
	p := newPrinter()
	p.doPrint(a)
	s := string(p.buf)
	p.free()
	return s
}

1. go内置的fmt中两个方法Print,Spring,如果仅仅是因为两个方法在输出方式的不同,就要写两种不同的输出方式,代码就太糟糕了

2. 这两个方法都调用了Fprint(wio.write),通过查看这个io.write可以知道是个接口而print的os.Stdout返回的是*File,这个也是实现了io.write中的Write方法

3. Sprint构建了一个&buf内存指针,所以也是实现了Write

类型断言

1. 类型断言是一个作用在接口值上的操作,写出来类似于x.(T),其中x是一个接口类型的表达式,而T是一个类型,类型断言会检查作为操作数的动态类型是否满足指定的类型断言,类型断言的X必须是一个接口类型

func main() {
	var w io.Writer
	w = os.Stdout
	f := w.(*os.File)
	if _, ok := w.(*bytes.Buffer);!ok {
		fmt.Println("不正确的类型")
	}
	fmt.Printf("%T",f)
}

2 使用switch完成类型选择

    // 类型选择
	var s string
	s = "name"
	//进行类型断言或者类型选择的时候,必须是一个接口类型
	switch interface{}(s).(type) {
	case int:
		fmt.Printf("int is %d",s)
	case string:
		fmt.Printf("stirng is %s",s)

	}