golang中定义的某个interface作为函数的入参时

函数的入参是某个interface，那么函数里调用interface里的方法时，如果方法里有修改结构体变量，会修改原有的变量么？

1.方法的接收器是指针，结构体的成员变量是指针变量。变量被修改了。
2.方法的接收器是指针，结构体的成员变量不是指针变量。变量被修改了。
3.方法的接收器不是指针，结构体的成员变量不是指针变量。变量没有被修改了。
4.方法的接收器不是指针，结构体的成员变量是指针变量。变量被修改了。

也就是方法的接收器或者成员变量有一方是指针，那么原来结构体的成员变量就会被修改。

package main

import "fmt"

type Reader interface {
    Read() int
}

type MyStruct struct {
    X, Y *int
}

func (m *MyStruct) Read() int {
    res := *m.X + *m.Y
    *m.X ++
    *m.Y ++
    return res
}

type MyStruct2 struct {
    X, Y int
}

func (m *MyStruct2) Read() int {
    res := m.X + m.Y
    m.X++
    m.Y++
    return res
}

type MyStruct3 struct {
    X, Y int
}

func (m MyStruct3) Read() int {
    res := m.X + m.Y
    m.X++
    m.Y++
    return res
}

type MyStruct4 struct {
    X, Y *int
}

func (m MyStruct4) Read() int {
    res := *m.X + *m.Y
    *m.X ++
    *m.Y ++
    return res
}

func run(r Reader) {
    fmt.Println(r.Read())
}

func main() {
    // 函数的入参是某个interface，那么函数里调用interface里的方法时，如果方法里有修改结构体变量，会修改原有的变量么？
    
    // 1.方法的接收器是指针，结构体的成员变量是指针变量。变量被修改了。
    x, y := 3, 4
    s := &MyStruct{&x, &y}
    run(s)
    fmt.Printf("1. x:%v,y:%v\n", *s.X, *s.Y)

    // 2.方法的接收器是指针，结构体的成员变量不是指针变量。变量被修改了。
    s2 := &MyStruct2{3, 4}
    run(s2)
    fmt.Printf("2. x:%v,y:%v\n", s2.X, s2.Y)

    // 3.方法的接收器不是指针，结构体的成员变量不是指针变量。变量没有被修改了。
    s3 := &MyStruct3{3, 4}
    run(s3)
    fmt.Printf("3. x:%v,y:%v\n", s3.X, s3.Y)

    // 4.方法的接收器不是指针，结构体的成员变量是指针变量。变量被修改了。
    x1, y1 := 3, 4
    s4 := MyStruct4{&x1, &y1}
    run(s4)
    fmt.Printf("4. x:%v,y:%v\n", *s4.X, *s4.Y)

}

/**
output:

7
1. x:4,y:5
7
2. x:4,y:5
7
3. x:3,y:4
7
4. x:4,y:5


*/