在Go中，如果类型T2基于类型T1，则存在任何类型的“继承".从T1到T2? [英] In Go, if type T2 is based on type T1, is there any sort of "inheritance" from T1 to T2?

问题描述

如果类型T2 基于类型T1 ，则除了共享相同的数据字段外， T1 和 T2 ?

If type T2 is based on type T1, other than sharing the same data fields, is there any relationship between T1 and T2?

package main
import "fmt"

type T1 struct { s string }
func (v *T1) F1() string { return v.s }

type T2 T1
func (v *T2) F2() string { return v.s }

func main() {
        var t1 = T1{ "xyz" }
        var t2 = T2{ "pdq" }
        s0 := t2.F1()                   // error - expected ok
        s1 := ((*T1)(&t2)).F1()         // ok - expected
        s2 := ((*T2)(&t1)).F2()         // ok - not expected
        fmt.Println( s0, s1, s2 )
}

我在这里缺乏了解

1. 希望 T2 将继承 T1 的方法，但事实并非如此.

1. was hoping that T2 would inherit T1's methods, but such is not the case.

期望将 T2 强制转换为 T1 ，因为它是从 T1

was expecting T2 could be coerced into T1, since it was derived from T1

惊讶于 T1 可以被强制为 T2 ，但是确实如此.

was surprised that T1 could be coerced into T2, but so it is.

似乎 T1 和 T2 之间的关系是完全对称的-尽管实际上是从T1推导得出的，但我找不到破坏对称性的任何东西.其他-还是幻觉?

it seems that the relationship between T1 and T2 is completely symmetrical - I cannot find anything that breaks the symmetry despite the fact one is actually derived from the other - or is this an illusion?

(注意:我不是批评或判断-我完全尊重所做的决定-只是确认我了解对我而言有什么违反直觉的想法-我确定我不是只有一个！)

(NOTE: I am not criticizing or judging - I entirely respect decisions made - just verifying I understand what is there that for me is counter-intuitive - I'm sure I'm not the only one!)

推荐答案

Go不支持面向对象的类型继承.

Go does not support object-oriented type inheritance.

是使用面向对象的语言吗?

为什么没有类型继承?

方法绑定到单个特定类型.

A method is bound to a single specific type.

方法声明绑定了方法的标识符.方法是表示绑定到基本类型，并且仅在选择器的选择器中可见该类型.

A method declaration binds an identifier to a method. The method is said to be bound to the base type and is visible only within selectors for that type.

您可以转换类型 T1 和 T2 .

值 x 可以已转换输入 T [何时] x 的类型和 T 相同的基础类型.

A value x can be converted to type T [when] x's type and T have identical underlying types.

例如，

package main

import (
    "fmt"
)

type T1 struct{ i int }

func (t T1) String() string { return "T1" }

type T2 T1

func (t T2) String() string { return "T2" }

func main() {
    t1 := T1{1}
    t2 := T2{2}
    fmt.Println(t1, t2)
    c1 := T1(t2)
    c2 := T2(t1)
    fmt.Println(c1, c2)
    t1 = T1(c2)
    t2 = T2(c1)
    fmt.Println(t1, t2)
}

Output:
T1 T2
T1 T2
T1 T2

这篇关于在Go中，如果类型T2基于类型T1，则存在任何类型的“继承".从T1到T2?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！