Declaring Fields

// Sample program to show how what we are doing is NOT embedding
// a type but just using a type as a field.
//示例程序演示我们所做的不是嵌入的。
// a类型,只是使用类型作为字段。
package main

import "fmt"

// user defines a user in the program.
type user struct {
    name  string
    email string
}

// notify implements a method notifies users 通知实现方法通知用户。
// of different events.
func (u *user) notify() {
    fmt.Printf("Sending user email To %s<%s>\n",
        u.name,
        u.email)
}

// admin represents an admin user with privileges. admin代表具有特权的admin用户。
type admin struct {
    person user // NOT Embedding
    level  string
}

func main() {

    // Create an admin user.
    ad := admin{
        person: user{
            name:  "admin1",
            email: "[email protected]",
        },
        level: "super",
    }
    // We can access fields methods.
    ad.person.notify()
}

/*
Sending user email To admin1<[email protected]>
*/

Embedding types

// Sample program to show how to embed a type into another type and
// the relationship between the inner and outer type.
//示例程序演示如何将类型嵌入到另一个类型中。
//内在与外在的关系。

package main

import "fmt"

// user defines a user in the program.
type user struct {
    name  string
    email string
}

// notify implements a method notifies users
// of different events.

//通知实现方法通知用户。
//不同的事件。
func (u *user) notify() {
    fmt.Printf("Sending user email To %s<%s>\n",
        u.name,
        u.email)
}

// admin represents an admin user with privileges.
type admin struct {
    user  // Embedded Type 埋入式
    level string
}

func main() {
    //  create an admin user
    ad := admin{
        user: user{
            name:  "tomcat",
            email: "[email protected]",
        },
        level: "super",
    }

    // We can access the inner type's method directly. 我们可以直接访问内部类型的方法。
    ad.user.notify()

    // The inner type's method is promoted. 提升了内部类型的方法。
    ad.notify()

}

Embedded types and interfaces

// Sample program to show how embedded types work with interfaces.

package main

import "fmt"

// notifier is an interface that defined notification
// type behavior.
// notifier是一个定义通知的接口。
// 类型的行为。

type notifier interface {
    notify()
}

// user defines a user in the program.
type user struct {
    name  string
    email string
}

// notify implements a method notifies users
// of different events.

func (u *user) notify() {
    fmt.Printf("send user email to%s<%s>\n",
        u.name,
        u.email)
}

// admin represents an admin user with privileges.
type admin struct {
    user
    level string
}

func main() {

    // Create an admin user.
    ad := admin{
        user: user{
            name:  "john smith",
            email: "[email protected]",
        },
        level: "super",
    }

    // Send the admin user a notification.
    // The embedded inner type's implementation of the
    // interface is "promoted" to the outer type.

    sendNotification(&ad)
    //   send user email tojohn smith<[email protected]>

}

// sendNotification accepts values that implement the notifier
// interface and sends notifications.
// sendNotification接受实现通知的值。
// 接口和发送通知。
func sendNotification(n notifier) {
    n.notify()

}

Outer and inner type interface implementations 外部和内部类型接口实现。

package main

import "fmt"

// notifier is an interface that defined notification
// type behavior.
type notifier interface {
    notify()
}

// user defines a user in the program.
type user struct {
    name  string
    email string
}

// notify implements a method notifies users
// of different events.
func (u *user) notify() {
    fmt.Printf("Sending user email To %s<%s>\n",
        u.name,
        u.email)
}

// admin represents an admin user with privileges.
type admin struct {
    user
    level string
}

// notify implements a method notifies admins
// of different events.
func (a *admin) notify() {
    fmt.Printf("Sending admin Email To %s<%s>\n",
        a.name,
        a.email)
}

func main() {

    // Create an admin user.
    ad := admin{
        user: user{
            name:  "john smith",
            email: "[email protected]",
        },
        level: "super",
    }

    // Send the admin user a notification.
    // The embedded inner type's implementation of the
    // interface is NOT "promoted" to the outer type.
    //发送管理用户通知。
    //嵌入式内部类型的实现。
    //界面不是“提升”到外部类型。
    sendNotification(&ad)

    // We can access the inner type's method directly. 我们可以直接访问内部类型的方法。
    ad.user.notify()

    // The inner type's method is NOT promoted. 内部类型的方法没有被提升。
    ad.notify()
}

// sendNotification accepts values that implement the notifier
// interface and sends notifications.
func sendNotification(n notifier) {
    n.notify()
}

/*
Sending admin Email To john smith<[email protected]>
Sending user email To john smith<[email protected]>
Sending admin Email To john smith<[email protected]>
*/

练习

// Copy the code from the template. Declare a new type called hockey
// which embeds the sports type. Implement the finder interface for hockey.
// When implementing the find method for hockey, call into the find method
// for the embedded sport type to check the embedded fields first. Then create
// two hockey values inside the slice of finders and perform the search.
//复制模板中的代码。宣布一种新型的曲棍球。
//这是体育运动的类型。实现曲棍球的finder接口。
//在实现曲棍球的查找方法时,请调用find方法。
//对于嵌入式运动类型,首先要检查嵌入式字段。然后创建
//两个曲棍球值,在切片的发现者和执行搜索。

package main

import (
    "fmt"
    "strings"
)

// finder defines the behavior required for performing matching. finder定义了执行匹配所需的行为。
type finder interface {
    find(needle string) bool
}

// sport represents a sports team. 体育代表队。
type sport struct {
    team string
    city string
}

// find checks the value for the specified term. 查找检查指定项的值。
func (s *sport) find(needle string) bool {
    return strings.Contains(s.team, needle) || strings.Contains(s.city, needle)
}

// hockey represents specific hockey information. 曲棍球代表特定的曲棍球信息。
type hockey struct {
    sport
    country string
}

// find checks the value for the specified term. 查找检查指定项的值。
func (h *hockey) find(needle string) bool {
    return h.sport.find(needle) || strings.Contains(h.country, needle)
}

func main() {
    // Define the term to find.
    needle := "Miami"

    // Create a slice of finder values and assign values
    // of the concrete hockey type.
    haystack := []finder{
        &hockey{sport{"Panthers", "Miami"}, "USA"},
        &hockey{sport{"Canadiens", "Montreal"}, "Canada"},
    }

    // Display what we are trying to find.
    fmt.Println("Searching For:", needle)

    // Range of each haystack value and check the term.
    for _, hs := range haystack {
        if hs.find(needle) {
            fmt.Printf("FOUND: %+v", hs)
        }
    }

}

/*
Searching For: Miami
FOUND: &{sport:{team:Panthers city:Miami} country:USA}
*/