Go语言中结构体字段与方法的可见性及封装实践

package mypackage

type mytype struct {
    size          string // 未导出字段，仅mypackage内可见
    hash          uint32 // 未导出字段，仅mypackage内可见
}

// doPrivate 是一个未导出的方法，仅mypackage内可见
func (r *mytype) doPrivate() string {
    return r.size
}

// Do 是一个导出的方法，mypackage外可见
func (r *mytype) Do() string {
    // 在mypackage内部，即使doPrivate是未导出的，也可以被同包内的其他方法调用
    return r.doPrivate()
}

// 示例：mypackage内其他函数访问mytype的未导出成员
func processMyType(m *mytype) string {
    // 允许访问未导出字段
    fmt.Println("Accessing unexported field size:", m.size)
    // 允许调用未导出方法
    return m.doPrivate() + " from processMyType"
}

// File: myinternaltype/myinternaltype.go
package myinternaltype

import "fmt"

// MyType 是一个导出的结构体，但其字段是未导出的
type MyType struct {
    size          string // 未导出字段，仅myinternaltype包内可见
    hash          uint32 // 未导出字段，仅myinternaltype包内可见
}

// newMyType 是一个未导出的构造函数，仅myinternaltype包内使用
func newMyType(s string, h uint32) *MyType {
    return &MyType{size: s, hash: h}
}

// DoPrivate 是一个未导出的方法，仅myinternaltype包内可见
func (r *MyType) doPrivate() string {
    fmt.Printf("Inside MyType.doPrivate, size: %s\n", r.size)
    return r.size
}

// NewMyType 是一个导出的构造函数，供外部包创建MyType实例
func NewMyType(s string, h uint32) *MyType {
    return newMyType(s, h) // 调用内部的newMyType
}

// DoSomethingPublic 是一个导出的方法，供外部包调用
func (r *MyType) DoSomethingPublic() string {
    // 在myinternaltype包内，可以访问其未导出字段和调用未导出方法
    return "Processed: " + r.doPrivate()
}

// AnotherInternalFunc 是myinternaltype包内的另一个函数
func AnotherInternalFunc(m *MyType) string {
    // 在myinternaltype包内，可以访问MyType的未导出字段和方法
    fmt.Println("AnotherInternalFunc accessing MyType's hash:", m.hash)
    return m.doPrivate() + " from AnotherInternalFunc"
}

// File: mypackage/mypackage.go
package mypackage

import (
    "fmt"
    "your_module_path/myinternaltype" // 替换为你的实际模块路径
)

// DemonstrateUsage 演示如何使用myinternaltype包中的MyType
func DemonstrateUsage() {
    // 外部包无法直接访问myinternaltype.MyType的未导出字段
    // var m myinternaltype.MyType // 允许声明，但无法直接访问内部字段
    // m.size = "small" // 编译错误：m.size是未导出的

    // 通过导出的构造函数创建MyType实例
    mt := myinternaltype.NewMyType("medium", 56789)

    // 只能调用导出的方法
    result := mt.DoSomethingPublic()
    fmt.Println("Result from MyType.DoSomethingPublic:", result)

    // 尝试调用myinternaltype.MyType的未导出方法将导致编译错误
    // mt.doPrivate() // 编译错误：mt.doPrivate是未导出的
}

// AnotherFunctionInMyPackage 是mypackage内的另一个函数
func AnotherFunctionInMyPackage() {
    // 在mypackage中，无法访问myinternaltype.MyType的未导出成员
    // var m *myinternaltype.MyType
    // m.doPrivate() // 编译错误
}