认识接口
Go 语言提供了另外一种数据类型即接口，它把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口。
接口使用
/* 定义接口 */
type interface_name interface {
method_name1 [return_type]
method_name2 [return_type]
method_name3 [return_type]
...
method_namen [return_type]
}
/* 定义结构体 */
type struct_name struct {
/* variables */
}
/* 实现接口方法 */
func (struct_name_variable struct_name) method_name1() [return_type] {
/* 方法实现 */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
/* 方法实现*/
}
/*方法调用*/
struct_name_variable.method_name() 理解接口和结构体
结构体是接口实现的载体。
我们把结构体比作机器人，接口比作外插芯片。
假设结构体是一个机器人（机器人有很多类别，因为不同的机器人所拥有的属性和功能不一样，有快递机器人、家务机器人、工作机器人等等，所以结构体也可以自定义为各种类型，因为它可以包含不同的属性和方法）；
机器人的功能是可以通过外插芯片来扩展的（就像一个电脑U盘一样），可以在芯片中加入一系列类似的功能，我们把接口比作这个外插芯片；
这个芯片可以插在各种机器人身上使用，并且机器人能够根据芯片功能显示出不同的作用。
机器人需要执行某项功能，而这项功能在芯片中统一管理，则可以将芯片插入机器人身上，并将机器人需要的功能植入到机器人，机器人就获得了这项功能。
同理。许多有关联的方法可统一在接口中管理。当结构体需要用到接口中的功能时，将接口函数在结构体中实现，之后结构体即可调用该方法。
实例
package main
import (
"fmt"
)
type Phone interface { //定义接口（生产芯片）
call()
}
type NokiaPhone struct { //定义结构体1（生产机器人1号）
}
func (nokiaPhone NokiaPhone) call() { //方法实现（将芯片插入机器人1号，并植入芯片中的call功能）
fmt.Println("I am Nokia, I can call you!")
}
type IPhone struct { //定义结构体2（生产机器人2号）
}
func (iPhone IPhone) call() { //方法实现（将芯片插入机器人2号，并植入芯片中的call功能）
fmt.Println("I am iPhone, I can call you!")
}
func main() {
var phone Phone
phone1 = new(NokiaPhone) //结构体实例化（机器人1号出厂）
phone1.call() //方法调用（机器人1号启动芯片植入的call功能）
phone2 = new(IPhone) //结构体实例化（机器人2号出厂）
phone2.call() //方法调用（机器人2号启动芯片植入的call功能）
}扩展
空接口
空接口(interface{})不包含任何的方法，正因为如此，所有的类型都实现了空接口，因此空接口可以存储任意类型的数值。
type Object interface{}
type Node struct {
Data Object
Next *Node
}this *习惯用法
//判断是否为空的单链表
func (this *List) IsEmpty() bool {
if this.headNode == nil {
return true
} else {
return false
}
}所列出的this只是变量名，人们用this作为变量名只是为了遵循方法实现的习惯。
实例（单链表的实现）
package linkedList
type Object interface{}
type Node struct {
Data Object
Next *Node
}
type List struct {
headNode *Node //头节点
}
//判断是否为空的单链表
func (this *List) IsEmpty() bool {
if this.headNode == nil {
return true
} else {
return false
}
}
//单链表的长度
func (this *List) Length() int {
cur := this.headNode
count := 0
for cur != nil {
count++
cur = cur.Next
}
return count
}
//获取头部节点
func (this *List) GetHeadNode() *Node {
return this.headNode
}
//从头部添加元素
func (this *List) Add(data Object) {
node := &Node{Data: data}
node.Next = this.headNode
this.headNode = node
}
//从尾部添加元素
func (this *List) Append(data Object) {
node := &Node{Data: data}
if this.IsEmpty() {
this.headNode = node
} else {
cur := this.headNode
for cur.Next != nil {
cur = cur.Next
}
cur.Next = node
}
}
//在指定位置添加元素
func (this *List) Insert(index int, data Object) {
if index < 0 {
this.Add(data)
} else if index > this.Length() {
this.Append(data)
} else {
pre := this.headNode
count := 0
for count < (index - 1) {
pre = pre.Next
count++
}
//当循环退出后，pre指向index -1的位置
node := &Node{Data: data}
node.Next = pre.Next
pre.Next = node
}
}
//删除指定元素
func (this *List) Remove(data Object) {
pre := this.headNode
if pre.Data == data {
this.headNode = pre.Next
} else {
for pre.Next != nil {
if pre.Next.Data == data {
pre.Next = pre.Next.Next
} else {
pre = pre.Next
}
}
}
}
//删除指定位置的元素
func (this *List) RemoveAtIndex(index int) {
pre := this.headNode
if index <= 0 {
this.headNode = pre.Next
} else if index >= this.Length() {
//报错 err
} else {
count := 0 //index = 3
for count != (index-1) && pre.Next != nil {
count++ //2
pre = pre.Next //2
}
pre.Next = pre.Next.Next
}
}
//是否包含某个元素
func (this *List) Contain(data Object) bool {
cur := this.headNode
for cur != nil {
if cur.Data == data {
return true
}
cur = cur.Next
}
return false
}测试代码在main.go中，相关测试如下
package main
import (
"algorithm/linkedList"
"fmt"
)
func main() {
list := linkedList.List{}
//1.往单链表末尾追加元素2, 3, 4, 5
list.Append(1)
list.Append(2)
list.Append(3)
list.Append(4)
//2.从头部添加元素head_node
list.Add("head_node")
fmt.Println("长度======", list.Length())
//3.判断是否为空链表
bool := list.IsEmpty()
fmt.Println(bool)
//4.在指定位置2插入元素 2indexValue
list.Insert(2, "2_index_value")
travselLinkList(&list)
//5.是否包含元素2_index_value
isContain := list.Contain("2_index_value")
fmt.Println("isContain[2_index_value]:", isContain)
//6.删除元素2_index_value
list.Remove("2_index_value")
travselLinkList(&list)
//7.从位置2删除元素
list.RemoveAtIndex(2)
travselLinkList(&list)
}
func travselLinkList(list *linkedList.List) {
//遍历
head := list.GetHeadNode()
for head != nil {
fmt.Println(head.Data)
head = head.Next
}
fmt.Println("--------------------")
}
