深入理解Go语言中的接口与指针：*interface的语义与最佳实践

package main

type IF interface {
    MyMethod(i int)
}

type AType struct {
    I *IF // 尝试定义一个指向接口的指针
}

func (a *AType) aFunc() {
    // 编译错误：type *IF does not have method MyMethod
    a.I.MyMethod(1) 
}

func main() {}

// 1. 值接收者方法
type MyType struct {
    Value int
}

func (mt MyType) MyMethod(i int) {
    // 这里的mt是MyType的一个副本
    mt.Value += i // 修改的是副本，不会影响原始MyType
    println("Value receiver method called, new value:", mt.Value)
}

// 2. 指针接收者方法
type MyPointerType struct {
    Value int
}

func (mpt *MyPointerType) MyMethod(i int) {
    // 这里的mpt是指向MyPointerType的指针
    mpt.Value += i // 修改的是原始MyPointerType
    println("Pointer receiver method called, new value:", mpt.Value)
}

package main

import "fmt"

type IF interface {
    MyMethod(i int)
    GetValue() int
}

// 具体实现类型，使用指针接收者
type MyConcreteType struct {
    Data int
}

func (mct *MyConcreteType) MyMethod(i int) {
    mct.Data += i // 通过指针修改原始对象
    fmt.Printf("MyMethod called on *MyConcreteType, Data is now: %d\n", mct.Data)
}

func (mct *MyConcreteType) GetValue() int {
    return mct.Data
}

type AType struct {
    I IF // 接口本身作为值类型
}

func (a *AType) aFunc() {
    if a.I != nil {
        a.I.MyMethod(10) // 直接调用接口方法
    }
}

func main() {
    // 创建一个MyConcreteType的实例
    myObj := &MyConcreteType{Data: 100} 

    // 将MyConcreteType的指针赋值给接口
    // 此时，接口I内部存储的是myObj的地址
    a := &AType{I: myObj} 

    fmt.Printf("Initial Data: %d\n", myObj.Data) // 100

    a.aFunc() // 调用aFunc，通过接口I调用MyMethod

    fmt.Printf("After aFunc, MyConcreteType Data: %d\n", myObj.Data) // 110 (被修改了)

    // 另一个例子：如果MyMethod是值接收者，则不会修改原始对象
    type MyValueType struct {
        Data int
    }

    func (mvt MyValueType) MyMethod(i int) {
        mvt.Data += i // 修改的是副本
        fmt.Printf("MyMethod called on MyValueType (value receiver), Data is now: %d\n", mvt.Data)
    }

    func (mvt MyValueType) GetValue() int {
        return mvt.Data
    }

    myValueObj := MyValueType{Data: 200}
    b := &AType{I: myValueObj} // 将MyValueType的值赋值给接口
    fmt.Printf("\nInitial ValueType Data: %d\n", myValueObj.Data) // 200
    b.aFunc() // 接口I内部持有MyValueType的副本，调用MyMethod修改的是副本
    fmt.Printf("After aFunc, MyValueType Data: %d\n", myValueObj.Data) // 200 (未被修改)
}

package main

type IF interface {
    MyMethod(i int)
}

type MyImpl struct{}

func (m MyImpl) MyMethod(i int) {
    println("MyImpl MyMethod called with:", i)
}

type AType struct {
    I *IF // 指向接口的指针
}

func (a *AType) aFunc() {
    // 必须显式解引用才能调用方法
    if a.I != nil && *a.I != nil {
        (*a.I).MyMethod(1) 
    }
}

func main() {
    var myIF IF = MyImpl{} // 创建一个接口值
    a := &AType{I: &myIF}  // 将接口值的地址赋给I
    a.aFunc()
}