默认是模块级别,使用pub变为公共级别

    接口命名跟结构体一样,要求首字母大写,建议以er风格结尾,非强制

    接口字段

    接口在其他编程语言中大部分都只能包含方法签名

    V语言中接口除了可以包含方法签名,也可以包含字段,虽然包含字段也可以转为方法签名,

    编译时会检查结构体及其组合结构体(子类)是否实现接口字段,

    只有字段名,字段类型,是否可变,都跟接口中的字段一致,才算实现了这个接口字段.

    3. interface PointInterface {
    4. mut:
    5.   x int //定义接口包含字段
    6.   y int
    7. }
    9. struct Point {
    10. mut:
    11.     x int //接口字段实现
    12.     y int
    13. }
    15. fn add(p1 PointInterface,p2 PointInterface) PointInterface {
    16.     mut p:=Point {}
    17.     p.x=p1.x+p2.x
    18.     p.y=p1.y+p2.y
    19.     return p
    20. }
    22. fn main() {    
    23.     p1:=Point{
    24.         x:1
    25.         y:2
    26.     }
    27.     p2:=Point {
    28.         x:3
    29.         y:4
    30.     }
    31.     p3:=add(p1,p2)
    32.     println('x:$p3.x,y:$p3.y')
    33. }
    1. interface Animal {
    2. mut:
    3.     name string
    4. }
    6. struct Cat {
    7.     name string //mut不匹配,编译不通过
    8. }
    10. fn main() {
    11.     mut animals := []Animal{}
    12.     animals << Cat{}
    13. }

    接口也可以像结构体那样有自己的方法,只要结构体实现了接口,就可以调用接口的方法

    接口组合

    接口也像结构体那样支持组合

    1. module main
    3. pub interface Reader{
    4.     read(mut buf []byte) ?int
    5. }
    7. pub interface Writer {
    8.     write(bug []byte) ?int
    9. }
    11. // 接口组合
    12. pub interface ReaderWriter {
    13.         Reader
    14.       Writer
    15. }
    17. //接口组合
    18. interface WalkerTalker {
    19.     Walker 
    20. }
    22. interface Talker {
    23.     nspeeches int
    24.     talk(msg string)
    27. interface Walker {
    28.     nsteps int
    29.     walk(newx int, newy int)
    30. }
    32. struct Abc {
    33. mut:
    34.     x         int
    35.     y         int
    36.     phrases   []string
    37.     nsteps    int = 1000 //实现接口中要求的字段
    38.     nspeeches int = 1000 //实现接口中要求的字段
    39. }
    41. //实现接口要求的方法
    42. fn (mut s Abc) talk(msg string) {
    43.     s.phrases << msg
    44.     s.nspeeches++
    45. }
    47. //实现接口要求的方法
    48. fn (mut s Abc) walk(x int, y int) {
    49.     s.x = x
    50.     s.y = y
    51.     s.nsteps++
    52. }
    54. fn main() {
    55.     mut wt := WalkerTalker(Abc{ 
    56.         x: 1
    57.         y: 1
    58.         phrases: ['hi']
    59.     })
    60.     wt.talk('my name is Wally')
    61.     wt.walk(100, 100)
    62.     if wt is Abc {
    63.         println(wt)
    64.     }
    65. }

    鸭子类型:只要结构体实现了接口定义的方法,就满足该接口的使用

    1. module main
    3. struct Dog {}
    5. struct Cat {}
    7. fn (d Dog) speak() string {
    8.     return 'woof'
    9. }
    11. fn (c Cat) speak() string {
    12.     return 'meow'
    13. }
    15. interface Speaker {
    16.     speak() string
    17. }
    19. fn perform(s Speaker) {
    20.     println(s.speak())
    21. }
    23. fn main() {
    24.     dog := Dog{}
    25.     cat := Cat{}
    26.     perform(dog) // "woof"
    27.     perform(cat) // "meow"

    接口可以作为结构体字段类型使用:

    获取接口变量的具体类型

    接口类型使用内置方法type_name()来返回接口变量的具体类型

    1. module main
    4.     speak() string
    5. }
    7. pub struct Cat {}
    8. pub fn (c Cat) speak() string {
    9.     return 'miao'
    10. }
    12. pub struct Dog {}
    14. pub fn (d Dog) speak() string {
    15.     return 'wang'
    16. }
    18. pub fn say(animal Animal) {
    19.     println(typeof(animal).name) // 只会返回接口名字Animal,不会返回具体类型
    20.     println(animal.type_name()) // 返回接口的具体类型
    21.     println(animal.speak())
    22. }
    24. fn main() {
    25.     cat:=Cat {}
    26.     say(cat)
    28.     dog:=Dog{}
    29.     say(dog)
    30. }

    使用is,!is对接口参数的具体类型进行判断

    使用match对接口类型参数进行匹配,跟match匹配联合类型一样,每一个分支都会自动造型,非常的好用

    1. module main
    3. struct Dog {
    4.     name1 string
    5. }
    7. struct Cat {
    8.     name2 string
    9. }
    11. fn (d Dog) speak() string {
    12.     return 'wang'
    13. }
    15. fn (c Cat) speak() string {
    16.     return 'miao'
    17. }
    19. interface Speaker {
    20.     speak() string
    21. }
    23. fn perform(s Speaker) {
    24.     if s is Dog { // 通过is操作符,判断接口类型是否是某一个具体类型
    25.         println('s is Dog')
    26.     }
    27.     if s !is Dog { // 通过!is操作符,判断接口类型不是某一个具体类型
    28.         println('s is not Dog')
    29.     }
    31.     //match对接口参数的类型匹配,跟匹配联合类型一样,每一个分支都会自动造型,非常的好用
    32.     match s {
    33.         Dog { println('s is Dog struct,name is $s.name1') }
    34.         Cat { println('s is Cat struct,name is $s.name2') }
    35.         else { println('s is: $s.type_name()') }
    36.     }
    37. }
    39. fn main() {
    40.     dog := Dog{ name1:'dog' }
    41.     cat := Cat{ name2:'cat' }
    42.     perform(dog) // "wang"
    43.     perform(cat) // "miao"

    判断类型是否实现接口