关于golang面向接口

go语言是一门面向接口的语言 不具有继承多态

传统语言的继承多态由go语言的接口完成 所以go语言的接口比较灵活

go语言接口由使用者定义 传统语言由实现者定义

先来一个简单的接口示例 

package mock //接口方法专用包

type Retriever struct{ //定义接口初始类型
	Conount string
}

func (r Retriever)Get(url string) string{ //接口方法实现
	return url
}

package main

import (
	"fmt"
	"awesomeProject1/test/retriever/reals"
)

type Retriever interface{ //定义接口
	Get(url string)string  //定义方法
}
func download(r Retriever)string{ //传递接口
	return r.Get("http://www.baidu.com")
}
func main(){
	var r Retriever //定义变量
	r  = mock.Retriever{"this is a fack baidu.com"} // 变量初始化
	fmt.Println(download(r)) //打印返回值
}//返回值为this is a fack baidu.com

上面的例子看出go语言的灵活性 先由使用者明确要使用的方法名称 而后由结构体创建方法

package reals

import (
	"time"
	"net/http"
	"net/http/httputil"
)

type Retriever struct{ //golang的“类”创建
	UserAgent string     //成员变量
	TimeOut time.Duration
}

func (r Retriever)Get(url string) string{ //成员函数
	resp, err := http.Get(url)            //测试是否成功连接url传输内容
	if err != nil {
		panic(err)                        //失败报错
	}

	result, err:= httputil.DumpResponse(resp,true) //爬取内容
	resp.Body.Close()                              //  关闭网页
	if err != nil {
		panic(err)
	}
	return  string(result)                            //返回爬取内容
}

package main

import (
	"fmt"
	"awesomeProject1/test/retriever/reals"
)

type Retriever interface{ //定义接口
	Get(url string)string  //定义方法
}
func download(r Retriever)string{ //传递接口
	return r.Get("http://www.alibaba.com")
}
func main(){
	var r Retriever //定义变量
	r  = reals.Retriever{"coco",time.Minute*5} // 变量初始化
	fmt.Printf("%T %v\n", r,r)
	//fmt.Println(download(r)) //打印返回值
}

上述例子中 r被reals.Retriever{}赋值 r究竟是什么东西让我们打印一下

返回结果为

reals.Retriever {coco 5m0s}

 由此可见 r其中有类型及参数

同时接口中的方法可以指针传递 在方法中

 

func (r *Retriever)Get(url string) string{ //指针传递

}

 

func main(){
	var r Retriever //定义变量
	r  = &reals.Retriever{"coco",time.Minute*5} // 变量初始化
	fmt.Printf("%T %v\n", r,r)
}

打印结果为

*reals.Retriever &{coco 5m0s}

 类型及参数皆为指针 注意一旦采用指针传递 对应的方法也必须加上指针符 否则无法传递理想数据

	realRetriever := r.(*reals.Retriever)
	fmt.Println(realRetriever.TimeOut)

同样 接口可以通过.（）赋值给变量 内部参数 需要注意的是结构体成员变量开头字母需大写 否则无法看到

interface不光是接口的关键字 interface{}还代表任何类型

package queue

type Queue []interface{}

func (q *Queue)Push(data interface{}){ //注意指针传递
	*q = append(*q,data)
}

func (q *Queue)Pop() interface{}{
	p := (*q)[0]
	*q = (*q)[1:]
	return p
}
func (q *Queue)IsEmpty()bool{
	return (*q)[0] == 0
}

package main

import (
	"awesomeProject1/test/queueentry/queue"
	"fmt"
)

func main(){
	r := queue.Queue{}
	r.Push("a")
	r.Push("b")
	r.Push(3)

	fmt.Println(r.Pop())
	fmt.Println(r.Pop())
	fmt.Println(r.Pop())
}//打印结果为a b 3

如果想要从任何类型interface{}中取得指定类型 要在类型变量后加.(想要转换的类型)

r.(int)

go语言的接口可以“继承” go语言中称为组合

type Retriever interface{
	Get(url string) string
}
type Poster interface{
	Post(url string, form map[string]string) string
}
type RetrievenPoster interface	{
	Retriever
	Poster
}

go语言中的组合加定义接口方法赋予了go语言接口的灵活性