go - 面向对象（3）-- 接口
go - 面向对象（3）
go面向对象编程思想-接口
在我们了解多态之前，必须先学习一下接口，在golang语言中，可以说接口还是面向对象编程的核心思想
基本介绍
interface类型可以定义一组方法，但是这些不需要实现。并且interface不能包含任何变量，到某个自定义类型的时候，再具体把这些方法写出来
基本语法
type 接口名 interface{
method1(参数列表) 返回值列表
method2(参数列表) 返回值列表
}
//实现接口所有方法
type 自定义类型 struct{
}
type 自定义类型 struct{
}
func (t 自定义类型) method1(参数列表) 返回值列表{
//方法实现
}
func (t 自定义类型) method2(参数列表) 返回值列表{
//方法实现
}
说明一下
1、接口里所有的方法都没有方法体，即接口的方法都是没有实现的方法。接口体现了程序设计的多态和高内聚低耦合的思想
2、Golang中的接口，不需要显式的实现。只要一个变量，含有接口类型中的所有方法，那么这个变量就实现这个接口。因为，Golang中没有implement这样的关键字，总之Golang的接口实现是基于方法来实现的，接口只是用于一个调度，只要方法可以实现，那么就可以接口
关于接口实现的一些细节
1、接口的本身不能创建实例，但是可以指向一个实现了该接口的自定义类型的变量（实例）
type Student struct{
Name string
}
func (stu Student) Say(){
fmt.Println("你好")
}
func Ainterface interface{
Say()
}
func main(){
var stu Student
var a Ainterface = stu
A.Say()
}
//此时如果没有Student来实现这个Say()的话，那么这个接口类型就无法实现
2、在Golang中，一个自定义类型需要将某个接口的所有方法都实现，才能说这个自定义类型是实现了该接口。
3、只要是自定义数据类型，就可以实现接口，不仅仅是结构体类型
type integer int
//即使这个integer 是定义了int类型，但是仍然是可以实现接口的方法
func (i integer) Say(){
fmt.Println("say = ", i)
}
func main(){
var i integer = 10
var b Ainterface = i
b.Say()
}
4、一个接口（比如A接口）可以继承多个别的接口（比如B、C接口），这是如果要实现A接口，也必须将B、C接口的方法也全部实现
5、interface里面不能有任何变量
6、interface类型默认是一个指针（引用类型），如果没有对interface初始化就使用，那么就会输出nil
ps：一个小错误
package main
import "fmt"
type Usb interface{
//声明两个没有实现的方法
Start()
Stop()
}
type Phone struct{
}
//让Phone实现Usb接口的方法
func (p *Phone) Start(){ //注意这个start和stop方法有什么不一样
fmt.Println("手机开始工作")
}
func (p Phone) Stop(){
fmt.Println("手机停止工作")
}
func main(){
var p Phone
var u Usb
u = &p //如果方法是引用指针的话，那么引用到接口也需要使用指针
u.Start()
}
接口的应用场景—接口的好处
一个实现sort的小例子
我们先来查看sort的源码
由上可知，需要一个满足sort.Interface接口的集合类型，如果我们一开始没有定义一个
package main
import (
"fmt"
"math/rand"
"sort"
)
//首先定义一个student的结构体
type Student struct{
Name string
class int
score int
}
//定义一个student结构体的集合
type Students []Student
func main(){
var stus Students
for i:=0;i<10;i++{ //定义十个student，不同的分数
stu := Student{
Name : fmt.Sprintf("student~%d",rand.Intn(100)),
class : rand.Intn(10),
score : rand.Intn(100),
}
stus = append(stus , stu)
}
for _,v := range stus{
fmt.Println(v) //输出排列之前的数组
}
fmt.Println("----------------------看看效果---------------------------")
sort.Sort(stus)
for _,v := range stus{
fmt.Println(v)
}
}
很显然报了一个错，大概就是不能使用Students这种type来使用，但是！只要我们用Students这种type来实现了sort这种interface所需要的方法，那我们就能够执行这一函数
所以我们将代码改良
package main
import (
"fmt"
"math/rand"
"sort"
)
//首先定义一个student的结构体
type Student struct{
Name string
class int
score int
}
//定义一个student结构体的集合
type Students []Student
//查看源码，sort就是调用这么一些方法，我们使用Students来实现
func (stus Students) Len() int{
return len(stus)
}
func (stus Students) Less(i, j int) bool{
return stus[i].score < stus[j].score
}
func (stus Students) Swap(i,j int){
stus[i],stus[j] = stus[j],stus[i]
}
func main(){
var stus Students
for i:=0;i<10;i++{ //定义十个student，不同的分数
stu := Student{
Name : fmt.Sprintf("student~%d",rand.Intn(100)),
class : rand.Intn(10),
score : rand.Intn(100),
}
stus = append(stus , stu)
}
for _,v := range stus{
fmt.Println(v) //输出排列之前的数组
}
fmt.Println("----------------------看看效果---------------------------")
sort.Sort(stus) //直接使用Sort函数
for _,v := range stus{
fmt.Println(v)
}
}
效果非常明显，很显然接口所需要的更多就是方法的实现，更加体现出golang中面向对象编程，重要的是方法的实现
关于继承和接口的区别
继承的价值更多的在于解决代码的复用性和可维护性
效果非常明显，很显然接口所需要的更多就是方法的实现，更加体现出golang中面向对象编程，重要的是方法的实现
关于继承和接口的区别
继承的价值更多的在于解决代码的复用性和可维护性
接口的价值在于：设计，设计好各种规范和方法，让其他自定义类型去实现这些方法。
关于多态
简单介绍一下
变量（实例）具体有多种形态，这是面向对象的第三大特征，在Go语言中，多态特征是通过接口实现的。可以按照统一的接口来调用不同的实现。这时接口变量就呈现出不同的形态。
类型断言
type Point struct{
x int
y int
}
func main(){
var a interface{} //定义一个a的空接口，空接口可以接手任意类型
var point Point = Point{1,2} //定义一个point结构体
a = point //将point类型赋值给a
var b Point
b = a //很显然，这段代码是不可以的，a的类型是interface{}，不能够直接赋值
fmt.Println(b)
}//会报错的啦
但是我们可以使用一个类型断言
type Point struct{
x int
y int
}
func main(){
var a interface{} //定义一个a的空接口
var point Point = Point{1,2} //定义一个point结构体
a = point //将point类型赋值给a
var b Point
b = a.(Point) //这个就是判断能否将a转化为Point类型
fmt.Println(b)
}
由于接口是一般类型，不知道具体类型，如果要转成具体类型，就需要使用类型断言