深入理解Go语言接口与指针：何时使用指针实现接口及避免常见陷阱

type IF interface {
    MyMethod(i int)
}

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

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() {
    // 示例，实际代码无法运行
}

package main

import "fmt"

// 定义接口
type IF interface {
    MyMethod(i int)
    GetValue() int
}

// 1. MyType 的方法使用值接收器
type MyType struct {
    value int
}

func (mt MyType) MyMethod(i int) { // 值接收器：修改的是mt的副本
    mt.value = i 
    fmt.Printf("MyType (value receiver): value set to %d (internal copy)\n", mt.value)
}

func (mt MyType) GetValue() int { // 值接收器
    return mt.value
}

// 2. PtrMyType 的方法使用指针接收器
type PtrMyType struct {
    value int
}

func (pmt *PtrMyType) MyMethod(i int) { // 指针接收器：修改的是原始对象
    pmt.value = i 
    fmt.Printf("PtrMyType (pointer receiver): value set to %d (original object)\n", pmt.value)
}

func (pmt *PtrMyType) GetValue() int { // 指针接收器
    return pmt.value
}

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

func main() {
    // 示例1: 使用值接收器实现的类型
    m1 := MyType{value: 10}
    a1 := &AType{I: m1} // 接口I持有m1的副本
    fmt.Printf("Before MyMethod (a1.I): %d\n", a1.I.GetValue()) // 10
    a1.I.MyMethod(20) // 修改的是接口内部的MyType副本
    fmt.Printf("After MyMethod (a1.I): %d\n", a1.I.GetValue()) // 20 (接口内部的副本被修改)
    fmt.Printf("Original m1 value: %d\n", m1.GetValue())     // 10 (m1原始值未变)

    fmt.Println("---")

    // 示例2: 使用指针接收器实现的类型
    m2 := &PtrMyType{value: 100} // 注意这里m2本身就是指向PtrMyType的指针
    a2 := &AType{I: m2}          // 接口I持有m2指向的原始对象的引用
    fmt.Printf("Before MyMethod (a2.I): %d\n", a2.I.GetValue()) // 100
    a2.I.MyMethod(200) // 修改的是m2指向的原始PtrMyType对象
    fmt.Printf("After MyMethod (a2.I): %d\n", a2.I.GetValue()) // 200
    fmt.Printf("Original m2 value: %d\n", m2.GetValue())     // 200 (m2指向的原始值已变)
}

package main

import "fmt"

type IF interface {
    MyMethod(i int)
}

type ConcreteType struct {
    data int
}

func (ct *ConcreteType) MyMethod(i int) {
    ct.data = i
}

type AType struct {
    I *IF // 这里I是一个指向接口的指针
}

func (a *AType) aFunc() {
    // 必须显式解引用才能调用方法
    // 增加nil检查以避免运行时panic
    if a.I != nil && *a.I != nil { 
        (*a.I).MyMethod(1) 
    }
}

func main() {
    ct := &ConcreteType{data: 10}
    var myIF IF = ct // myIF现在是一个接口值，持有ct的指针

    a := &AType{I: &myIF} // a.I 现在是一个指向 myIF