类型

在声明一个新类型之后,声明一个该类型的方法之前,需先确定:这个类型的本质是什么?如果给这个类型增加或删除某个值,是要创建一个新值,还是要更改当前的值?如果要新值,就选择值接收者;如果要修改当前值,就选择指针接收者。这决定了 程序内部传递这个类型的值的方式:是按值做传递,还是按指针做传递。

1. 内置类型

包含数值类型、字符串类型和布尔类型
这些类型本质上都是原始类型,在操作其值时,应该传递其对应的值的副本。

2. 引用类型

包含切片、映射、通道、接口和函数类型
每个引用类型创建的标头值(引用类型创建的变量),都包含一个指向底层数据结构的指针。
所以通过复制来传递一个引用类型的值的副本,本质上就是在共享底层数据结构

3. 结构类型

待补充
结构类型的本质既可以是原始的,也可以是非原始的。

4. 看一个标准库中的接口 及 实现例子

4.1 io.Writer接口

// Writer is the interface that wraps the basic Write method.
//
// Write writes len(p) bytes from p to the underlying data stream.
// It returns the number of bytes written from p (0 

4.2 bytes.Buffer实现了该接口

// Write appends the contents of p to the buffer, growing the buffer as
// needed. The return value n is the length of p; err is always nil. If the
// buffer becomes too large, Write will panic with ErrTooLarge.
func (b *Buffer) Write(p []byte) (n int, err error) {
    b.lastRead = opInvalid
    m := b.grow(len(p))
    return copy(b.buf[m:], p), nil
}

4.3 接口实现多态

当方法的接收参数是某个接口时,可以将不同的实现该接口的值作为参数传递给方法,从而实现采取不同行为的能力。
方法fmt.Fprintf的第一个参数是io.Writer接口

// Fprintf formats according to a format specifier and writes to w.
// It returns the number of bytes written and any write error encountered.
func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
    p := newPrinter()
    p.doPrintf(format, a)
    n, err = w.Write(p.buf)
    p.free()
    return
}

方法io.Copy的第一个参数也是io.Writer接口

func Copy(dst Writer, src Reader) (written int64, err error) {
    return copyBuffer(dst, src, nil)
}

4.4 简单的例子展示io多态

func ByteBuffer()  {
    var b bytes.Buffer

    //将字符串写入Buffer
    b.Write([]byte("Hello go"))

    //使用Fprintf将字符串拼接到Buffer
    fmt.Fprintf(&b, ", nice to meet you")

    //将Buffer的内容写到Stdout
    io.Copy(os.Stdout, &b)
}

最终输出结果:
Hello go, nice to meet you

5. Go语言的接口规则

因为涉及到指针,规则相比Java来说略微复杂一些。

Go语言的方法有接收者这一说词,从Java的角度来看,就是方法的调用者。在Java中,调用者就是调用者。但是Go语言中,分值接收者指针接收者。但规则不外乎如下两种:

  1. 如果一个接口的实现类型,用指针接收者来作为方法的接收者(其实就是Java的调用者),那么只能用该类型的指针对象来调用该接口。

  2. 如果一个接口的实现类型,用值接收者来作为方法的接收者,那么既可以用指针对象也可以用值的副本来调用该接口。

以下是Go语言给出的方法集规则:

Values Methods Receivers remark
T (t T) 如2
*T (t T) and (t *T) 如1
Methods Receivers Values remark
(t T) T and *T 如2
(t *T) *T 如1

5. 多态

如下实现了一个简单的多态:

//person接口
type personInter interface {
    sayName()
}

//用户
type user struct {
    name string
}
func (u *user) sayName()  {
    fmt.Printf("User name is %s n", u.name)
}

//管理员
type admin struct {
    name string
}
func (u *admin) sayName()  {
    fmt.Printf("Admin name is %s n", u.name)
}

func Test()  {
    logger := user{"logger"}
    //letsSayYourName(logger)  //这是错误调用,不能用值的副本logger去调用接收者为指针接收者的实现方法
    letsSayYourName(&logger)

    admin := admin{"admin"}
    letsSayYourName(&admin)
}

//方法入参为接口,只要实现了该接口的实现类型都可作为入参
func letsSayYourName(person personInter)  {
    person.sayName()
}

最终输出:
User name is logger
Admin name is admin

6. 嵌入类型

先介绍一下Go语言所谓的嵌入类型:
嵌入类型是将已有的类型直接声明在新的结构类型中,被嵌入的类型被称为新的外部类型的内部类型。
个人理解Go语言中的嵌入类型类似于Java中的组合

6.1 示例1 — 外部类型调用内嵌类型的方法

type animal struct {
    name string
}

func (u *animal) sayName() {
    fmt.Printf("name is %s n", u.name)
}

//管理员类型,内嵌一个user类型
type person struct {
    animal  //嵌入类型
    name string
}

func TestInnerType() {
    ad := person{animal{"logger"}, "admin"}
    ad.animal.sayName()
    ad.sayName()
}

输出:
name is logger
name is logger

小结:

  • 可以将内嵌类型的方法提升到外部类型
  • ad.sayName()调用内嵌类型的方法输出的还是内嵌类型的属性

6.2 示例2 — 外部类型调用内嵌类型的实现接口

//接口
type foodInter interface {
    sayFoodName()
}

//苹果
type apple struct {
    name string
}

//超市
type market struct {
    apple  //内嵌类型 -- 苹果
}

func (a *apple) sayFoodName()  {
    fmt.Printf("food name is %s n", a.name)
}

func TestInnerTypeInterface()  {
    walmart := market{ apple{"ApplyX"}}

    //重点是这句
    //用于实现接口的内部类型的方法,被提升到了外部类型
    commonSayName(&walmart)
}

func commonSayName(food foodInter)  {
    food.sayFoodName()
}

输出:
food name is ApplyX

小结:

  • 由于内部类型的提升,内部类型实现的接口会自动提升到外部类型。这意味着由于内部类型的实现,外部类型也同样实现了这个接口。

6.3 示例3 — 外部类型覆盖内嵌类型的实现接口

相比于示例2,增加了类型market自己的实现方法以此覆盖内嵌类型的实现接口,并在类型market中添加了属性marketName以便输出展示。

//接口
type foodInter interface {
    sayFoodName()
}

//苹果
type apple struct {
    name string
}

//超市
type market struct {
    marketName string
    apple  //内嵌类型 -- 苹果
}

func (a *apple) sayFoodName()  {
    fmt.Printf("food name is %s n", a.name)
}

func (m *market) sayFoodName()  {
    fmt.Printf("market name is %s n", m.marketName)
}

func TestInnerTypeInterface()  {
    walmart := market{ "walmart", apple{"ApplyX"}}

    //重点是这句
    //用于实现接口的内部类型的方法,被提升到了外部类型
    commonSayName(&walmart)
}

func commonSayName(food foodInter)  {
    food.sayFoodName()
}

输出:
market name is walmart

小结:

  • 由于内部类型的提升,内部类型实现的接口会自动提升到外部类型。这意味着由于内部类型的实现,外部类型也同样实现了这个接口。

7. 公开或未公开的标识符

类似于Java中的public、private等,你可以控制方法或变量的访问权限。Go语言当然也提供了这种功能。
Go语言支持从包里公开或隐藏标识符。如果一个标识符,如下示例中的counter以小写字母开头,即包外代码不可见(类似Java的private),如果一个标识符,如下示例中的PublicCounter以大写字母开头,这个标识符就是公开的,即包外代码可见(类似Java的public)。

7.1 原始类型

//声明一个未公开的计数器
type counter int

//声明一个公开的计数器
type PublicCounter int

当然,我们也可以给未公开的标识符,如counter写一个公开的取值函数,或者写一个工厂函数新建一个counter

//取值函数
func GetCounter(value int) counter {
  return counter
}

//工厂函数
func New(value int) counter {
  return counter(value)
}

工厂函数命名为New只是Go语言中的一个习惯。

7.2 结构类型中的未公开字段

结构类型中带有未公开类型的字段

//公开的用户类型
type Admin struct {
    Name string    //公开的Name字段
    email string    //未公开的email字段
}

如果在其它包中创建该类型,并赋值email字段,在定义阶段是不会报错的,如下不会直接报错(identifier是包名):

ad := identifier.Admin{"admin", "admin@email.com"}

但是在运行的时候,会报错,错误如下:

# command-line-arguments
.main.go:43: implicit assignment of unexported field 'email' in identifier.Admin literal

7.3 访问未公开的内嵌对象中的公开字段

identifier包中定义如下结构类型,apple是未公开的结构类型,但是其Name字段是公开的。

type apple struct {
    Name string
}

//公开类型的Tree对象
type Tree struct {
    TreeName string //公开类型的TreeName
    apple           //未公开的apple类型
}

在其它包中,可以利用内部对象属性升级为外部对象的特性,为tree的未公开内嵌类型apple的公开字段Name设值。

tree := identifier.Tree{TreeName: "MoneyTree"}
tree.Name = "apply"
fmt.Printf("%v n", tree)

文章来源于互联网,如有雷同请联系站长删除:Go In Action — 类型的本质、接口、多态、嵌入类型、标识符

发表评论