发现输出哪里不同

package main

import "fmt"

// 父类结构体 Car
type Car struct {
   
     
    weight int
    name string
}

// 父方法
func (c Car) Run() {
   
     
    fmt.Println("Running")
}

// 子结构体 Train
type Train struct {
   
     
    // 匿名
    Car
    wheel int
}

// 子方法
func (p Train) String() string {
   
     
    str := fmt.Sprintf("name=[%s],wheel=[%d]",p.name,p.wheel)
    return str
}

func main() {
   
     
    var train Train
    train.weight = 140000
    train.name = "train"
    train.wheel = 8
    
    fmt.Println(train)
    train.Run()
    fmt.Printf("%s",train)
}

/* 结果
name=[train],wheel=[8]
Running
name=[train],wheel=[8]
*/

1. 接口定义

  • Interface 类型可以定义一组方法,不需要实现,并且不能包含任何变量,称之为接口。
  • 接口不需要显示的实现,只需要一个变量,含有接口类型中的所有方法,那么这个变量就实现了这个接口,如果一个变星含有了多个 interface 类型的方法,那么这个变量就实现了多个接口。

语法

type example interface {
   
     
    Method1(参数列表)返回值列表
    Method2(参数列表)返回值列表
    ...
}

示例:空接口使用

package main

import "fmt"

// 空接口(空指针)
type Test interface{
   
     }

func main() {
   
     
    // 声明接口
    var t Test
    var a interface{
   
     }	// 等于 var a Test
    var b int
    a = b
    fmt.Printf("a 数据类型:%T\n",a)
    fmt.Printf("Test 数据类型:%T\n",t)
}

/* 结果
a 数据类型:int
Test 数据类型:<nil>
*/

示例:结构体使用接口打印信息

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.Println("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 Student struct {
   
     
    Name string
    Age int
    Score float32
}

// 接口定义
type Test interface {
   
     
    Print()
    Sleep()
}

// 指针类型实现接口
func (p *Student) Print() {
   
     
    fmt.Println("name:",p.Name)
    fmt.Println("age:",p.Age)
    fmt.Println("score:",p.Score)
}

// 接口中包含多个方法,如果要使用此接口,就要实现接口中包含的所有方法
func (p *Student) Sleep() {
   
     
    fmt.Println("学生在睡觉")
}

func main() {
   
     
    var t Test
    var stu Student = Student {
   
     
        Name: "zhangsan",
        Age: 18,
        Score: 90,
    }

    // 接口应用
    t = &stu
    t.Print()
    t.Sleep()
}

/*
name: zhangsan
age: 18
score: 90
学生在睡觉
*/ 

2. 多态

示例:为不同数据类型的实体提供统一的接口。

package main

import "fmt"

// 学生
type Student struct {
   
     
	Name string
	Age int
	Score float32
}

// 教师
type Teacher struct {
   
     
	Name string
	Age int
	Class int
}

// 接口定义
type Test interface {
   
     
	Print()
	Sleep()
}

// 学生实现接口
func (p Student) Print() {
   
     
	fmt.Println("name:",p.Name)
	fmt.Println("age:",p.Age)
	fmt.Println("score:",p.Score)
}

func (p Student) Sleep() {
   
     
	fmt.Println("学生在睡觉")
}

// 教师实现接口
func (t Teacher) Print() {
   
     
	fmt.Println("name:",t.Name)
	fmt.Println("age:",t.Age)
	fmt.Println("class:",t.Class)
}

func (t Teacher) Sleep() {
   
     
	fmt.Println("教师在休息")
}

func main() {
   
     
	var t Test
	var stu Student = Student {
   
     
		Name: "zhangsan",
		Age: 18,
		Score: 90,
	}

	var tea Teacher = Teacher {
   
     
		Name: "lisi",
		Age: 50,
		Class: 01,
	}

	// 多态表现
	t = stu
	t.Print()
	t.Sleep()
	fmt.Println("---------------------------")
	t = tea
	t.Print()
	t.Sleep()
}
 
/*
name: zhangsan
age: 18
score: 90
学生在睡觉
---------------------------
name: lisi
age: 50
class: 1
教师在休息
*/

继承关系实现多态

package main

import "fmt"

// 父结构体
type Persion struct {
   
     
    Name string
    Age int
}

// 学生子结构体
type Student struct {
   
     
	Persion
	Score float32
}

// 教师子结构体
type Teacher struct {
   
     
	Persion
	Class int
}

// 接口定义
type Test interface {
   
     
	Print()
	Sleep()
}

// 学生实现接口
func (p Student) Print() {
   
     
	fmt.Println("name:",p.Name)
	fmt.Println("age:",p.Age)
	fmt.Println("score:",p.Score)
}

func (p Student) Sleep() {
   
     
	fmt.Println("学生在睡觉")
}

// 教师实现接口
func (t Teacher) Print() {
   
     
	fmt.Println("name:",t.Name)
	fmt.Println("age:",t.Age)
	fmt.Println("class:",t.Class)
}

func (t Teacher) Sleep() {
   
     
	fmt.Println("教师在休息")
}

func main() {
   
     
	var t Test
    // 学生初始化
	var stu Student
	stu.Name = "zhangsan"
	stu.Age = 18
	stu.Score = 90

    // 教师初始化
	var tea Teacher 
	tea.Name = "lisi"
	tea.Age = 50
	tea.Class = 01

	// 多态表现
	t = stu
	t.Print()
	t.Sleep()
	fmt.Println("---------------------------")
	t = tea
	t.Print()
	t.Sleep()
}
 
/*
name: zhangsan
age: 18
score: 90
学生在睡觉
---------------------------
name: lisi
age: 50
class: 1
教师在休息
*/

综合示例:在电脑上定义一个 USB 接口,实现鼠标、U 盘存储、电扇的功能

package main

// 电脑结构体
type Computer struct {
   
     
    Brand string	// 品牌
    Price float32	// 价格
}

// USB 接口
type USB interface {
   
     
    mouse()		// 鼠标功能
    store()		// 存储
    fan()		// 风扇
}

// 接口实现
func (c Computer) mouse() {
   
     
    fmt.Println("鼠标控制")
}
func (c Computer) store() {
   
     
    fmt.Println("U 盘存储")
}
func (c Computer) fan() {
   
     
    fmt.Println("吹风扇")
}

func main() {
   
     
    // 接口变量
    var u USB
    // 笔记本初始化
    var computer Computer
    computer.Brand = "thinkpad"
    computer.Price = 5000
    // 接口调用
    u = computer
    u.mouse()
    u.store()
    u.fan()
}

/*
鼠标控制
U 盘存储
吹风扇
*/

示例:多接口的实现

package main

import "fmt"

// 接口1
type Test1 interface {
   
     
    Print()
}

// 接口2
type Test2 interface {
   
     
    Sleep()
}

type Student struct {
   
     
    Name string
    Age int
}

// 多接口实现
func (s Student) Print() {
   
     
    fmt.Println("name:",s.Name)
    fmt.Println("age:",s.Age)
}

func (s Student) Sleep() {
   
     
    fmt.Println("正在睡觉")
}

func main() {
   
     
    // 接口1变量
    var t1 Test1
    // 接口2变量
    var t2 Test2
    // 初始化结构体
    var stu Student = Student {
   
     
        Name: "zhangsan",
        Age: 18,
    }
    
    // 多接口应用
    t1 = stu
    t2 = stu
    t1.Print()
    t2.Sleep()
}

/*
name: zhangsan
age: 18
正在睡觉
*/

3. 系统接口调用

示例:使用接口进行排序

结构体切片插入

package main

import (
    "fmt"
    "math/rand"
)

// 结构体
type Student struct {
   
     
    Name string
    Age int
    Score float32
}

// 切片
type StudentArray []Student

func main() {
   
     
    // Student 切片
    var stus StudentArray
    // 生成 10 个结构体放入切片中
    for i:=0;i<10;i++ {
   
     
        var stu Student = Student {
   
     
            Name: fmt.Sprintf("stu%d",rand.Intn(100)),
            Age: rand.Intn(120),
            Score: rand.Float32()*100,
        }
        // 结构体元素存放入切片中
        stus = append(stus,stu)
    }
    
    // 遍历
    for _,v := range stus {
   
     
        fmt.Println(v)
    }
}

/* 结果
{stu81 87 66.45601}
{stu59 1 68.682304}
{stu25 20 9.696952}
{stu0 14 81.36399}
{stu62 89 31.805817}
{stu74 51 29.310184}
{stu37 26 20.318687}
{stu66 8 86.249146}
{stu47 67 75.2573}
{stu88 30 69.67192}
*/

示例:实现排序

API 官方地址:https://pkg.go.dev/sort#Interface

package main

import (
    "fmt"
    "math/rand"
    "sort"
)

// 结构体
type Student struct {
   
     
    Name string
    Age int
    Score float32
}

// 切片
type StudentArray []Student

// 实现 sort 接口
func (sa StudentArray) Len() int {
   
     
    return len(sa)
}
func (sa StudentArray) Less(i,j int) bool {
   
     
    return sa[i].Name > sa[j].Name	// < 升序
}
func (sa StudentArray) Swap(i,j int) {
   
     
    sa[i],sa[j]=sa[j],sa[i]
} 

func main() {
   
     
    // Student 切片
    var stus StudentArray
    // 生成 10 个结构体放入切片中
    for i:=0;i<10;i++ {
   
     
        var stu Student = Student {
   
     
            Name: fmt.Sprintf("stu%d",rand.Intn(100)),
            Age: rand.Intn(120),
            Score: rand.Float32()*100,
        }
        // 结构体元素存放入切片中
        stus = append(stus,stu)
    }
    
    // 遍历
    for _,v := range stus {
   
     
        fmt.Println(v)
    }
    fmt.Println("--------------------")
    
    // 排序
    sort.Sort(stus)
    
    // 遍历
    for _,v := range stus {
   
     
        fmt.Println(v)
    }
}

/*
{stu81 87 66.45601}
{stu59 1 68.682304}
{stu25 20 9.696952}
{stu0 14 81.36399}
{stu62 89 31.805817}
{stu74 51 29.310184}
{stu37 26 20.318687}
{stu66 8 86.249146}
{stu47 67 75.2573}
{stu88 30 69.67192}
--------------------
{stu88 30 69.67192}
{stu81 87 66.45601}
{stu74 51 29.310184}
{stu66 8 86.249146}
{stu62 89 31.805817}
{stu59 1 68.682304}
{stu47 67 75.2573}
{stu37 26 20.318687}
{stu25 20 9.696952}
{stu0 14 81.36399}
*/

4. 接口嵌套

示例:文件读写测试

package main

import "fmt"

type Reader interface {
   
     
    Read()
}

type Writer interface {
   
     
    Writer()
}

// 接口嵌套
type ReadWriter interface {
   
     
    Reader
    Writer
}

// 文件结构体
type File struct {
   
     }

// 实现 Reader 接口
func (f *File) Read() {
   
     
    fmt.Println("文件读取")
}

// 实现 Writer 接口
func (f *File) Writer() {
   
     
    fmt.Println("文件写入")
}

// 读写操作函数
func Test(rw ReadWriter) {
   
     
    rw.Read()
    rw.Writer()
}

func main() {
   
     
    // 初始化文件
    var f File
    Test(&f)
}

/* 结果
文件读取
文件写入
*/

5. 类型断言

作用:因为接口是一般类型,需要明确具体类型的时候就需要使用类型断言。

package main

import "fmt"

func main() {
   
     
    var a interface{
   
     }
    var b int
    a = b
    // 断言赋值
    c := a.(int)
    fmt.Printf("类型:%T\n",c)
}

/*
类型:int
*/

示例:断言判断

package main

import "fmt"

func Test(t interface{
   
     }) {
   
     
    // 转换类型判断
    v,err := t.(int)
    if err == false {
   
     
        fmt.Println("convert type err")
        return
    }
    v++
    fmt.Println(v)
}

func main() {
   
     
    var a int
    Test(a)
}

/*
1
*/

示例:多类型判断

package main

import (
	"fmt"
)

// 传递多个类型数据
// 长度不固定,类型不固定的数据传递给 items
// ... 表示长度不固定,interface{} 空接口表示任意数据类型
func classifier(items ...interface{
   
     }) {
   
     
	// i 是下标,x 是值(k/v)
	for i, x := range items {
   
     
		// 变量.(type) 只能作用在 Switch 语句中,专门用于类型判断
		switch x.(type) {
   
     
		case bool:
			fmt.Printf("%d is a bool\n", i)
		case int, int32, int64:
			fmt.Printf("%d is a int\n", i)
		case float32, float64:
			fmt.Printf("%d is a float\n", i)
		case string:
			fmt.Printf("%d is a string\n", i)
		default:
			fmt.Printf("unkown")
		}
	}
}

func main() {
   
     
	classifier("zhangsan", 18, 90.5, false, nil)
}

/*
0 is a string
1 is a int
2 is a float
3 is a bool
unkown
*/

6. 链表使用

示例

package main

import "fmt"

// 节点结构体
type LinkNode struct {
   
     
    data interface{
   
     }
    next *LinkNode
}

// 链表结构体
type Linkstruct {
   
     
    head *LinkNode
    tail *LinkNode
}

// 从头部插入
func (p *Link) InsertHead(data interface{
   
     }) {
   
     
    node := &LinkNode {
   
     
        data: data,
        next: nil,
    }
    // 判断是否为空链表
    if p.head == nil && p.tail == nil {
   
     
        p.head = node
        p.tail = node
        return
    }
    // 当前节点的 next 是原头部节点
    node.next = p.head
    // 更新头部
    p.head = node
}

// 从尾部插入
func (p *Link) InsertTail(data interface{
   
     }) {
   
     
    node := &LinkNode {
   
     
        data: data,
        next: nil,
    }
    // 判断是否为空链表
    if p.head == nil && p.tail == nil {
   
     
        p.head = node
        p.tail = node
        return
    }
    // 原尾部节点的 next 是当前节点
    p.tail.next = node
    // 更新尾部
    p.tail = node
}

// 遍历方法
func (p *Link) Req() {
   
     
    lp := p.head
    for lp != nil {
   
     
        fmt.Println(lp)
        lp = lp.next
    }
}

func main() {
   
     
    // 定义链表
    var intLinkLink
    for i := 0; i < 10; i++ {
   
     
        // intLink.InsertHead(i)
        intLink.InsertTail(i)
    }
    intLink.Req()
}

/*
&{0 0xc000004090}
&{1 0xc0000040a8}
&{2 0xc0000040c0}
&{3 0xc0000040d8}
&{4 0xc0000040f0}
&{5 0xc000004108}
&{6 0xc000004120}
&{7 0xc000004138}
&{8 0xc000004150}
&{9 <nil>}
*/

注意:切片不可以赋值给空接口,只能单独每个元素赋值

var a []int
var b []interface
b = a	// 出现报错