从 Struct 到 Interface 办法的进阶

❝

能够遗憾，但不要懊悔。

咱们留在这儿，从来不是情不自禁。

——— 而是挑选在这儿经历日子

❞

概述

Go 言语的面向目标编程有三个重要的思维：封装、承继和多态。

封装

Go 言语经过 struct 结构体的办法来完成封装，结构体能够包括各种类型的变量和办法，能够将一组相关的变量和办法封装在一起。运用首字母大小写控制变量和办法的访问权限，完成了信息躲藏和访问控制。

承继

Go 言语中没有传统的承继机制，可是能够运用嵌入式类型来完成类似承继的效果，将一个类型嵌入到另一个类型中，从而承继嵌入类型的办法和特点。嵌入式类型的特点是能够直接访问嵌入类型的特点和办法，不需求经过接口或许其他办法进行转换。在 Go 言语中，能够经过 struct 嵌套和 interface 嵌套来完成承继的效果。

多态

Go 言语经过接口来完成多态，一个类型只需求完成了接口的一切办法，就能够被赋值给该接口类型的变量。这样能够完成类似于面向目标言语中的多态性。多态性使得程序能够根据上下文环境自动挑选适宜的办法完成，提高了代码的灵敏性和可复用性。

代码实战

常规函数写法

在这个示例中，函数和结构体是分离的，函数接纳结构体指针类型作为参数，需求手动传递结构体的指针。虽然这种办法有一定的缺陷，调用会比较费事，但它愈加符合基于过程式编程思维的设计理念，行将一个大问题拆分红多个小问题，并经过函数处理这些小问题。适用于初学者关于代码的简单操作。长处就只有易于理解。

package test
import (
    "fmt"
    "testing"
)
type Mobile struct {
    User  string  `json:"user"`
    Brand string  `json:"brand"`
    Prise float64 `json:"prise"`
}
func CallUp(m *Mobile) {
    fmt.Printf("%s is using %.2f mobile phone to make a call.\n", m.User, m.Prise)
}
func Storage(m *Mobile) {
    fmt.Printf("%s is using a %s mobile phone to transfer data.\n", m.User, m.Brand)
}
func Charge(m *Mobile) string {
    return fmt.Sprintf("%s is charging a %s phone.\n", m.User, m.Brand)
}
func Game(m *Mobile, name string) {
    fmt.Printf("%s is playing the game of '%s'.\n", m.User, name)
}
func TestExample(t *testing.T) {
    iPhone := Mobile{
        User:  "Tom",
        Brand: "iPhone 15 Pro MAX",
        Prise: 12688.00,
    }
    CallUp(&iPhone)
    Game(&iPhone, "Card")
    Storage(&iPhone)
    fmt.Printf(Charge(&iPhone))
}

调用结构体类型上的办法

调用结构体类型上的办法表现了面向目标编程的封装思维。封装的中心是将数据和行为打包在一起，经过揭露和私有的办法来躲藏完成细节。这样能够使得代码愈加模块化、安全、易于维护，并且愈加符合实际国际中的抽象模型。

相比于上面的函数调用，调用结构体类型上的办法能够使调用办法时不用手动传递结构体实例目标，只需聚焦于办法参数本身，提高了代码的可读性和易用性。这也符合面向目标编程的简洁性和代码重用性的思维。

提示：在代码注释中类比了 Python 中类的写法。

package test
import (
    "fmt"
    "testing"
)
// class Mobile(object)
type Mobile struct {
    User  string  `json:"user"`
    Brand string  `json:"brand"`
    Prise float64 `json:"prise"`
}
// def __init__(user, brand, prise)
func NewMobile(user string, brand string, prise float64) *Mobile {
    return &Mobile{User: user, Brand: brand, Prise: prise}
}
// def call_up(self)
func (m *Mobile) CallUp() {
    fmt.Printf("%s is using %.2f mobile phone to make a call.\n", m.User, m.Prise)
}
// def storage(self)
func (m *Mobile) Storage() {
    fmt.Printf("%s is using a %s mobile phone to transfer data.\n", m.User, m.Brand)
}
// def charge(self)
func (m *Mobile) Charge() string {
    return fmt.Sprintf("%s is charging a %s phone.\n", m.User, m.Brand)
}
// def game(self, name)
func (m *Mobile) Game(name string) {
    fmt.Printf("%s is playing the game of '%s'.\n", m.User, name)
}
func TestExample(t *testing.T) {
    applePhone := NewMobile("Tom", "iPhone 15 Pro MAX", 12688.00)
    applePhone.CallUp()
    applePhone.Game("Card")
    applePhone.Storage()
    fmt.Printf(applePhone.Charge())
}

调用接口类型上的办法

接口实例： 是指界说一个接口类型，并将详细的结构体类型的实例传递给它。

调用接口类型上的办法，将接口与结构体类型分隔，使接口具有更广泛的适用性。运用 “接口实例” 能够完成更灵敏的代码设计，因为能够在运行时动态地挑选要运用的完成类型。

同时，因为接口只关怀办法的签名，而不关怀详细完成办法，因此能够将不同的结构体类型传递给同一个接口，从而完成面向目标思维的多态性。

在这个示例中，界说了一个 USB 接口和 PlayBoy 接口，它们都包括各自的办法。在测试函数中调用这两个接口的办法时需求别离调用。这两个接口之间没有直接的联络或关联，它们是彼此独立的。如果你想将这两个接口组合在一起，能够运用 “嵌入式接口”。

package test
import (
    "fmt"
    "testing"
)
var (
    applePhone, huaweiPhone *Mobile
)
func init() {
    applePhone = NewMobile("Tom", "iPhone 15 Pro MAX", 12688.00)
    huaweiPhone = NewMobile("John", "Huawei Meta 40 Pro", 8888.00)
}
type USB interface {
    Storage()
    Charge() string
}
type PlayBoy interface {
    Game(name string)
}
type Mobile struct {
    User  string  `json:"user"`
    Brand string  `json:"brand"`
    Prise float64 `json:"prise"`
}
func NewMobile(user string, brand string, prise float64) *Mobile {
    return &Mobile{User: user, Brand: brand, Prise: prise}
}
func (m *Mobile) CallUp() {
    fmt.Printf("%s is using %.2f mobile phone to make a call.\n", m.User, m.Prise)
}
func (m *Mobile) Storage() {
    fmt.Printf("%s is using a %s mobile phone to transfer data.\n", m.User, m.Brand)
}
func (m *Mobile) Charge() string {
    return fmt.Sprintf("%s is charging a %s phone.\n", m.User, m.Brand)
}
func (m *Mobile) Game(name string) {
    fmt.Printf("%s is playing the game of '%s'.\n", m.User, name)
}
func TestExample(t *testing.T) {
    USB.Storage(applePhone)
    fmt.Printf(USB.Charge(huaweiPhone))
    PlayBoy.Game(huaweiPhone, "LOL")
}

嵌入式接口

嵌入式接口： 是一种将一个接口嵌入到另一个接口中的技能，嵌入的接口中的一切办法都会被承继到当前接口中。经过接口的嵌套，能够将多个接口组合成一个更大的接口，从而使代码愈加简洁、灵敏。这也表现了面向目标编程中的承继特性。

在这个示例中，界说了一个 IPhone 接口，它嵌入了 USB 接口和 PlayBoy 接口，以及 CallUp() 办法。从而能够运用这三个接口中的一切办法。经过这种办法，咱们能够将不同的接口组合成一个更大的接口，以便更方便地运用这些办法。在测试函数中，咱们创建了一个 Mobile 类型的实例，并将其转换为 IPhone 类型的接口实例 p，然后能够运用 p 调用 Mobile 结构体中完成的 CallUp()、Game()、Storage() 和 Charge() 办法。

package test
import (
    "fmt"
    "testing"
)
type IPhone interface {
    USB
    PlayBoy
    CallUp()
}
type USB interface {
    Storage()
    Charge() string
}
type PlayBoy interface {
    Game(name string)
}
type Mobile struct {
    User  string  `json:"user"`
    Brand string  `json:"brand"`
    Prise float64 `json:"prise"`
}
func (m *Mobile) CallUp() {
    fmt.Printf("%s is using %.2f mobile phone to make a call.\n", m.User, m.Prise)
}
func (m *Mobile) Storage() {
    fmt.Printf("%s is using a %s mobile phone to transfer data.\n", m.User, m.Brand)
}
func (m *Mobile) Charge() string {
    return fmt.Sprintf("%s is charging a %s phone.\n", m.User, m.Brand)
}
func (m *Mobile) Game(name string) {
    fmt.Printf("%s is playing the game of '%s'.\n", m.User, name)
}
func TestExample(t *testing.T) {
    newMobile := &Mobile{User: "John", Brand: "Huawei Meta 40 Pro", Prise: 8888.00}
    var p IPhone = newMobile
    p.CallUp()
    p.Game("Card")
    p.Storage()
    fmt.Printf(p.Charge())
}

调用比照

代码示例：

package test
import (
    "fmt"
    "testing"
)
type IO interface {
    Reader() IO
    Writer(string) IO
}
type Disk struct {
    storage string
}
func (d *Disk) Reader() IO {
    fmt.Println(d.storage)
    return d
}
func (d *Disk) Writer(s string) IO {
    d.storage = s
    return d
}
func TestExample(t *testing.T) {
    disk := Disk{
        storage: "Hi Bro~",
    }
    // 办法1
    fmt.Println(disk.storage)
    // 办法2
    disk.Writer("Bonjour").Reader()
    // 办法3
    IO(&disk).Writer("Hola").Reader()
    // 办法4
    IO.Writer(&disk, "What's up, man?").Reader()
    // 弥补
    var io IO = &disk // 创建了interface变量，并将其赋值为指向Disk类型的指针
    io.Writer("你好").Reader()
    // 总归，以上几种办法完成的效果是相同的，但它们的语法和用法略有不同。
}

办法比照：

序号	代码	描绘
办法1	`fmt.Println(disk.storage)`	直接打印struct实例的特点值（私有不主张直接运用）。
办法2	`disk.Writer("xxx").Reader()`	运用原生struct上绑定的办法，链式调用，将多个操作衔接在一起，代码比较简洁。
办法3	`IO(&disk).Writer("xxx").Reader()`	经过将struct实例转换成接口类型来调用接口办法，适用于需求运用不同的完成类型来满足接口办法的情况，相同运用了办法链的办法，代码较为直观。
办法4	`IO.Writer(&disk, "xxx").Reader()`	直接调用接口类型的办法，传递完成类型的struct实例作为第一个参数传入，相同运用了办法链的办法，代码看起来也很简单。

除了办法1某些场景下不主张，办法2-4这三种办法都能够运用，详细挑选哪一种办法取决于个人的编码习惯和项目要求，可根据实际需求进行挑选。

Go 的面向对象编程技巧

从 Struct 到 Interface 办法的进阶

目录

概述

代码实战

常规函数写法

调用结构体类型上的办法

调用接口类型上的办法

嵌入式接口

调用比照

作者信息

Go 的面向对象编程技巧

从 Struct 到 Interface 办法的进阶

目录

概述

代码实战

常规函数写法

调用结构体类型上的办法

调用接口类型上的办法

嵌入式接口

调用比照

相关文章

Python：常用内建属性——__getattribute__属性拦截器使用详解

为自己量身打造一个 Rust 项目模板/脚手架

ChatGPT 中文指令指南，教会你如何使用chatgpt实现中文你想要的答案

外观模式，一个每天都在用，却被多数人忽略的模式

作者信息

Python：常用内建属性——getattribute属性拦截器使用详解