一、接口定义
概念: Interface类型可以定义一组方法，不需要实现，并且不能包含任何变量，称之为接口。
接口不需要显式的实现，只需要一个变量，含有接口类型中的所有方法，那么这个变量就实现了这个接口，如果一个变显含有了多个interface类型的方法，那么这个变量就实现了多个接口。
接口是一个或多个方法签名的集合。
任何类型的方法集中只要拥有该接口'对应的全部方法'签名。
就表示它 "实现" 了该接口，无须在该类型上显式声明实现了哪个接口。
这称为Structural Typing。
所谓对应方法，是指有相同名称、参数列表 (不包括参数名) 以及返回值。
接口只有方法声明，没有实现，没有数据字段。
接口可以匿名嵌入其他接口，或嵌入到结构中。
对象赋值给接口时，会发生拷贝，而接口内部存储的是指向这个复制品的指针，既无法修改复制品的状态，也无法获取指针。
只有当接口存储的类型和对象都为nil时，接口才等于nil。
接口调用不会做receiver的自动转换。
接口同样支持匿名字段方法。
接口也可实现类似OOP中的多态。
空接口可以作为任何类型数据的容器。
一个类型可实现多个接口。
接口命名习惯以 er 结尾。
1.接口名：使用type将接口定义为自定义的类型名。Go语言的接口在命名时，一般会在单词后面添加er，如有写操作的接口叫Writer，有字符串功能的接口叫Stringer等。接口名最好要能突出该接口的类型含义。
2.方法名：当方法名首字母是大写且这个接口类型名首字母也是大写时，这个方法可以被接口所在的包（package）之外的代码访问。
3.参数列表、返回值列表：参数列表和返回值列表中的参数变量名可以省略。
举个例子：
type writer interface{
Write([]byte) error
}
当你看到这个接口类型的值时，你不知道它是什么，唯一知道的就是可以通过它的Write方法来做一些事情。
空接口
空接口是指没有定义任何方法的接口。因此任何类型都实现了空接口。
空接口类型的变量可以存储任意类型的变量。
package main
import "fmt"
//空接口
type Test interface
func main() {
//声明接口
var t Test
var a interface{}
var b int
a = b
fmt.Printf("a数据类型:%T\n", a)
fmt. Printf("Test数据类型:%T\n", t)
}
运行结果
a的类型:int，a的值:0
Test的数据类型:<nil>，t的值:<nil>
package main
import "fmt"
func main() {
// 定义一个空接口x
var x interface{}
s := "pprof.cn"
x = s
fmt.Printf("type:%T value:%v\n", x, x)
i := 100
x = i
fmt.Printf("type:%T value:%v\n", x, x)
b := true
x = b
fmt.Printf("type:%T value:%v\n", x, x)
}
运行结果
type:string value:pprof.cn
type:int value:100
type:bool value:true
package main
import "fmt”
type student struct {
Name string
Age int
score float32
}
//接口定义:接口是功能的抽象
type Test interface {
Print()
}
//指针类型实现接口
func (p *Student) Print() {
fmt.Println("name: ",p.Name)
fmt.Print1n("age:", p.Age)
fmt.Println("score:", p.Score)
}
/*值类型实现接口
func (p Student)Print(){
fmt.Println("name: ",p.Name)
fmt.Println("age:", p.Age)
fmt.Println("score:", p.Score)
}
*/
func main(){
var t Test
var stu Student = Student{
Name: "zhangsan",
Age: 18,
Score:90,
}
//结构体实现接口功能t = stu值类型使用t - &stu
t.print()
}
运行结果
Name: zhangsan
Age: 18
Score:90
package main
import "fmt"
//定义一个结构体
type Car struct {
name string
color string
}
//定义接口
type Cry interface {
call()
Sleep()
}
//使用接口
func (c *Car) call() {
fmt.Printf("name:%s\n", c.name)
fmt.Printf("color:%s\n", c.color)
}
func (c *Car) Sleep() {
fmt.Println("加油 梦想")
}
func main() {
//定义接口变量
var t Cry
var car Car = Car{
name: "audiRs7",
color: "black",
}
t = &car
t.call()
t.Sleep()
}
name:audiRs7
color:black
加油 梦想
package main
import "fmt"
//父类
type Persion struct {
Name string
Age int8
}
type Women struct {
Persion
Looks string
}
type Men struct {
Persion
Money float32
}
//定义接口
type Move interface {
Sleep()
Action()
}
func (w Women) Action() {
fmt.Printf("name:%s\n", w.Name)
fmt.Printf("Age:%d\n", w.Age)
fmt.Printf("Looks:%s\n", w.Looks)
}
func (w Women) Sleep() {
fmt.Println("正在休息")
}
func (m Men) Action() {
fmt.Printf("name:%s\n", m.Name)
fmt.Printf("Age:%d\n", m.Age)
fmt.Printf("money:%f\n", m.Money)
}
func (m Men) Sleep() {
fmt.Println("正在休息")
}
func main() {
var t Move
var wo Women
wo.Name = "zhangsan"
wo.Age = 20
wo.Looks = "漂亮"
t = wo
t.Action()
t.Sleep()
fmt.Println("-----------------")
var m Men
m.Name = "zhangsan"
m.Age = 20
m.Money = 13433545
t = m
t.Action()
t.Sleep()
}
name:zhangsan
Age:20
Looks:漂亮
正在休息
-----------------
name:zhangsan
Age:20
money:13433545.000000
正在休息
package main
import "fmt"
type Sayer interface {
say()
}
// Mover 接口
type Mover interface {
move()
}
//dog既可以实现Sayer接口，也可以实现Mover接口。
type dog struct {
name string
}
// 实现Sayer接口
func (d dog) say() {
fmt.Printf("%s会叫汪汪汪\n", d.name)
}
// 实现Mover接口
func (d dog) move() {
fmt.Printf("%s会动\n", d.name)
}
func main() {
var x Sayer
var y Mover
var a = dog{name: "旺财"}
x = a
y = a
x.say()
y.move()
}
运行结果
旺财会叫汪汪汪
旺财会动
package main
import "fmt"
//在电脑上定义一个uSB接口，实现鼠标，u盘存储，电扇的功能
//父类 usb
type Usb struct {
MouseName string
Uname string
FanName string
}
type USB interface {
mouse()
U()
Fan()
}
func (u Usb) mouse() {
fmt.Printf("我是鼠标,名字叫:%s\n", u.MouseName)
}
func (u Usb) U() {
fmt.Println("我是u盘\n", u.Uname)
}
func (u Usb) Fan() {
fmt.Println("我是风扇\n", u.FanName)
}
func main() {
var t USB
var us Usb
us.MouseName = "雷蛇"
us.Uname = "666"
us.FanName = "风扇"
t = us
t.mouse()
t.Fan()
t.U()
}
运行结果
我是鼠标,名字叫:雷蛇
我是风扇
风扇
我是u盘
666
package main
import (
"fmt"
"math/rand"
"sort"
)
//定义结构体
type Student struct {
Name string
Age int
score float32
}
//定义切片
type StudentArray []Student
//定义sort接口
func (s StudentArray) Len() int {
return len(s)
}
func (s StudentArray) Less(i, j int) bool {
return s[i].Name < s[j].Name
}
func (s StudentArray) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
}
func main() {
//切片
var Stu StudentArray
//生成10个结构体放入切片中
for i := 0; i < 10; i++ {
var stu = Student{
Name: fmt.Sprintf("stu%d:", rand.Intn(100)),
Age: rand.Intn(100),
score: rand.Float32() * 100,
}
//元素追加
Stu = append(Stu, stu)
}
//排序
sort.Sort(Stu)
//遍历
for _, v := range Stu {
fmt.Println(v)
}
}
运行结果
{stu0: 94 81.36399}
{stu25: 40 9.696952}
{stu37: 6 20.318687}
{stu47: 47 75.2573}
{stu59: 81 68.682304}
{stu62: 89 31.805817}
{stu66: 28 86.249146}
{stu74: 11 29.310184}
{stu81: 87 66.45601}
{stu88: 90 69.67192}
package main
import "fmt"
//定义读写接口
type Reader interface {
read()
}
type Wirter interface {
wirter()
}
//嵌套接口
type ReaderWirter interface {
Reader
Wirter
}
//定义一个结构体
type file struct {
wen string
xie string
}
//接口实现（方法定义）
func (f *file) read() {
fmt.Println("读的功能", f.wen)
}
func (f *file) wirter() {
fmt.Println("写的功能", f.xie)
}
//读写操作函数（接口作为入参）
func Test(rw ReaderWirter) {
rw.read()
rw.wirter()
}
func main() {
var f = file{
wen: "你真漂亮",
xie: "谢谢",
}
Test(&f)
}
运行结果
读的功能 你真漂亮
写的功能 谢谢
标签：fmt,接口,学习,var,func,go,main,type From： https://www.cnblogs.com/pearlcity/p/16755372.html