package main
import "fmt"
type Person struct {
age int
name string
sex bool
}
type MPerson struct {
Person // 匿名字段
id int
}
func main() {
var mperson MPerson = MPerson{Person{18, "xiaohua", true}, 1}
fmt.Println(mperson)
}
fmt.Println(mperson.Person)
package main
import "fmt"
type Person struct {
age int
name string
sex bool
}
type MPerson struct {
Person
int
}
func main() {
var mperson MPerson = MPerson{Person{18, "xiaohua", true}, 1}
fmt.Println(mperson.Person, mperson.int)
}
package main
import "fmt"
type Person struct {
age int
name string
sex bool
}
type MPerson struct {
*Person
int
}
func main() {
var mperson MPerson = MPerson{&Person{18, "xiaohua", true}, 1}
fmt.Println(*(mperson.Person), mperson.int)
}
package main
import "fmt"
type Person struct {
age int
name string
sex bool
}
type MPerson struct {
Person
age int
}
func main() {
var mperson MPerson = MPerson{Person{18, "xiaohua", true}, 1}
fmt.Println(mperson)
}
注:
如果想要输出MPerson中的Person中的age
可以这么写:
fmt.Println(mperson.Person.age)
可以发现Go和C++还是有区别的, 此处是Person.age, 而不是Person::age, 注意之
package main
import "fmt"
type Person struct {
age int
id int
}
func (obj Person)f() {
fmt.Println(obj.age)
}
func main() {
person := Person{18, 1}
person.f()
}
注:
func (obj Person)f()
表示这是关联到Person的方法, 之后的调用就可以通过Person对象来通过.来使用该方法
package main
import "fmt"
type Person struct {
age int
id int
}
func (obj Person)f() {
fmt.Println("hello")
}
func main() {
p := &Person{18, 1}
p.f() // 用指针去调用也是可以的
}
package main
import "fmt"
type Person struct {
age int
id int
}
func (obj Person)f() {
obj.age = 10
}
func main() {
p := &Person{18, 1}
p.f()
fmt.Println(p)
}
注:
答案是改不了
因为编译器先把p转化成*p, 再去调用f(), 这就是值传递语义, 所以改不了, 注意
package main
import "fmt"
type Person struct {
age int
id int
}
func (obj Person)f() {
fmt.Println("hello")
}
type MPerson struct {
Person
name string
}
func main() {
p := MPerson{Person{18, 1}, "xiaohua"}
p.f()
}
注:
MPerson内部包含了Person的匿名字段, 不仅继承了成员, 也继承了方法
package main
import "fmt"
type Person struct {
age int
id int
}
func (obj Person)f() {
fmt.Println("hello")
}
type MPerson struct {
Person
name string
}
func (obj MPerson)f() {
fmt.Println("hello everyone")
}
func main() {
p := MPerson{Person{18, 1}, "xiaohua"}
p.f()
}
注:
子类重写了父类的方法, 子类在调用的时候默认先从自己的作用域去找方法, 找不到再去父类作用域找
如果想调用父类中的同名的方法, 可以这么写:
p.Person.f()
package main
import "fmt"
type Person struct {
age int
id int
}
func (obj Person)f() {
fmt.Println("hello")
}
func main() {
p := Person{18, 1}
function := p.f
function()
}
package main
import "fmt"
type Person struct {
age int
id int
}
func (obj Person)f() {
fmt.Println("hello")
}
func main() {
p := Person{18, 1}
function := (Person).f
function(p)
}
type 接口的类型名 interface {
方法名
}
package main
import "fmt"
type Inter interface {
f(data int)
}
type Person struct {
age int
name string
}
func (person Person)f(data int) {
fmt.Println(data)
}
func main() {
var myinterface Inter
p := Person{18, "xiaohua"}
myinterface = p
myinterface.f(10)
}
注:
如果想将对象赋值给接口, 必须这个对象实现了接口的全部方法, 否则会报错
type Inter interface {
f(data int)
}
type Int2er interface {
Inter
f2()
}
注:
在这段代码中, Inter就是子集, Int2er就是超集
超集可以转化成子集, 反过来错误
可以用C++的多态来类比理解,
超集理解成子类, 子集理解成父类, 转化可以理解成赋值操作
package main
import "fmt"
func main() {
var i interface{} = 1
fmt.Println(i)
i = "hello"
fmt.Println(i)
}
注:
可见, 空接口可以接收任意类型的值
package main
import "fmt"
func print(args... interface{}) {
for _, data := range args {
fmt.Println(data)
}
}
func main() {
print(1, "hello")
}