封装

package main

import "fmt"

type people struct {
	Name string
	age  int
}

// 定义工厂模式函数
func NewPeople(name string) *people {
	return &people{
		Name: name,
	}
}

func (p *people) SetAge(age int) {
	if age > 0 {
		p.age = age
	} else {
		fmt.Println("传入年龄不正确")
	}
}

func (p *people) GetAge() int {
	return p.age
}

func main() {
	p := NewPeople("张三")
	p.SetAge(18)
	fmt.Println(p.Name)
	fmt.Println(p.age)
}

继承

package main

import "fmt"

type animal struct {
	Age    int
	Weight float32
}

func (an *animal) Shout() {
	fmt.Println("喊叫")
}

func (an *animal) Show() {
	fmt.Printf("动物的年龄：%v，动物的体重：%v", an.Age, an.Weight)
	fmt.Println()
}

// 定义结构体进行复用
type Cat struct {
	animal
}

func (c *Cat) scratch() {
	fmt.Println("喵喵挠人")
}

func main() {
	cat := &Cat{}
	cat.Age = 10
	cat.Weight = 100
	cat.Show()
	cat.Shout()
	cat.scratch()
}

go中虽然保留了多继承，但是不建议使用

package main

import "fmt"

type A struct {
	a int
	b string
}

type B struct {
	c int
	d string
	a int
}

type C struct {
	A
	B
}

func main() {
	var c = C{A{10, "100"}, B{20, "200", 30}}
	fmt.Println(c.A.a)
	fmt.Println(c.B.a)
	fmt.Println(c.b)
	fmt.Println(c.b)
	fmt.Println(c.d)
}

接口

定义规范，让别人来实现,golang中不需要显示实现接口，比java语法松散

package main

import "fmt"

type say interface {
	sayHello()
}

type China struct {
}

func (person China) sayHello() {
	fmt.Println("你好")
}

type English struct {
}

func (person English) sayHello() {
	fmt.Println("hello")
}

// 定义函数，专门用来各国人打招呼,接受具备say接口能力的变量
func greet(s say) {
	s.sayHello()
}
func main() {
	c := China{}

	e := English{}

	greet(c)
	greet(e)
}

多态

在Golang中多态通过接口实现

func main() {
c := China{}
e := English{}
greet(c)
greet(e)
} //此时是多态的一种体现

断言

func greet(s say) {
s.sayHello()
//断言写法
var c = s.(China) //判断是否可以转化为China类型
c.chinaFunc()
}
func main() {
c := China{}
//e := English{}
greet(c)
//greet(e)
}

第二种写法

func greet(s say) {
s.sayHello()
//断言写法
//var c = s.(China) //判断是否可以转化为China类型
//c.chinaFunc()
ch, flag := s.(China)
if flag {
ch.chinaFunc()
} else {
fmt.Println("转化失败")
}
}

e {
	sayHello()
}

type China struct {
}

func (person China) sayHello() {
	fmt.Println("你好")
}

type English struct {
}

func (person English) sayHello() {
	fmt.Println("hello")
}

// 定义函数，专门用来各国人打招呼,接受具备say接口能力的变量
func greet(s say) {
	s.sayHello()
}
func main() {
	c := China{}

	e := English{}

	greet(c)
	greet(e)
}

多态

在Golang中多态通过接口实现

func main() {
c := China{}
e := English{}
greet(c)
greet(e)
} //此时是多态的一种体现

断言

func greet(s say) {
s.sayHello()
//断言写法
var c = s.(China) //判断是否可以转化为China类型
c.chinaFunc()
}
func main() {
c := China{}
//e := English{}
greet(c)
//greet(e)
}

第二种写法

func greet(s say) {
s.sayHello()
//断言写法
//var c = s.(China) //判断是否可以转化为China类型
//c.chinaFunc()
ch, flag := s.(China)
if flag {
ch.chinaFunc()
} else {
fmt.Println("转化失败")
}
}