通学go语言系列之面向对象（四）

绝地灬酷狼 2022-10-10 11:12 138阅读 0赞

> 通学技术，面向区块链编程

## oop1、自定义结构体 ##

package main
    
    import "fmt"
    
    /* oop--面向对象 自定义结构 现代编程，都讲究面向对象编程 作为一门比较潮的go语言来说 面向对象自然也是支持的 而面向对象的三要素分别是 封装、继承、多态 然我们来看看go是怎么玩转他们的吧 */
    
    // 首先我们的go 忽略了class的概念 转而用结构体来声明对象
    /* 说明: Go语言作为一门基于包管理的开发语言 如果想将自己的结构体作为公共包被其他包导入，需 要将结构体的首字母大写，同样地，结构体内部的字 段和函数希望被外部包访问也需要将首字母大写。 */
    type Person struct { 
    	name string
    	age int
    	sex string
    	// 战斗力
    	fight int
    }
    
    func main(){ 
    	// 定义并初始化
    	p1 := Person{ "渣渣辉",30,"man",5}
    	fmt.Println(p1)
    
    	// 先定义后赋值
    	var p2  Person
    	p2.age = 10
    	p2.name = "胖渣渣"
    	p2.sex = "woman"
    	// +v的打印方式 可以更详细地显示结构体内容
    	fmt.Printf("%+v\n",p2)
    
    }

## oop2、封装 ##

package main
    
    import (
    	"fmt"
    	"math"
    )
    
    // 当整个世界都说你不行的时候 你必须要大声地对他们说 我行
    /* 封装: 1.在结构体外部定义 2.方法一定要体现出调用者，方法只能被调用者类型的对象调用 格式： func (obj objT) funcName([params list] [return list]) */
    func main() { 
    	p1 := Point{ 0.0, 0.0}
    	p2 := Point{ 3.0,4.0}
    	fmt.Println(getDis(p1,p2))
    	fmt.Println(p2.getDis2(p1))
    }
    
    type Point struct { 
    	x, y float64
    }
    
    func getDis(p1, p2 Point) float64 { 
    	return math.Sqrt((p2.x-p1.x)*(p2.x-p1.x) + (p2.y-p1.y)*(p2.y-p1.y))
    }
    
    // 只能被Point类型的对象调用
    func (this Point) getDis2(p Point) float64 { 
    	return math.Sqrt((this.x-p.x)*(this.x-p.x) + (this.y-p.y)*(this.y-p.y))
    }

## oop3、组合 ##

package main
    
    import "fmt"
    
    /** 结构体内嵌 说明： 我们都知道 在面向对象的世界里，有两种主要模式 一种是我们所说的继承 而另外一种就是我们就是我们的组合 例如，儿子会继承爸爸的财产，他们都同事继承人的普遍特性吃喝拉撒 而人都是有手脑眼口鼻等这些对象组合而成的 */
    
    // 组合
    func main(){ 
    	p1 := Person1{ "渣渣辉",30,"man",5}
    	s1 := Superman{ 
    		strength: 100000,
    		speed: 19000,
    		p:p1,//逗号必须有
    	}
    	s1.p.setAge(40)
    	s1.print()
    }
    
    // 同包下 结构体名称不能相同
    type Person1 struct{ 
    	name string
    	age int
    	sex string
    	fright int
    }
    
    // 引用类型
    func (p *Person1) setAge(age int){ 
    	p.age = age
    }
    
    type Superman struct{ 
    	strength int
    	speed int
    	p Person1
    }
    
    func (s Superman) print(){ 
    	fmt.Printf("%+v\n",s)
    }

## oop4、结构体内嵌–继承 ##

package main
    
    import "fmt"
    
    /** 结构体内嵌(embed) --go中没有类似于java的extends、solidity的is这类直接表征继承的关键字 而是采用了更为直接的方式 结构体内嵌 */
    
    func main(){ 
    
    	p1 := Person2{ "渣渣辉",30,"man",5}
    	s1 :=Superman1{ 
    		strength: 100000,
    		speed: 9000,
    		// 正确的写法
    		Person2 : p1,
    	}
    	// 子类直接调用父类的方法 继承财产、能力、品性更直接更方便啦
    	s1.setAge(50)
    	s1.print()
    
    }
    
    type Person2 struct { 
    	name string
    	age int
    	sex string
    	fight int
    }
    
    type Superman1 struct { 
    	strength int
    	speed    int
    	// 结构体内嵌的写法
    	Person2
    }
    
    func (p *Person2) setAge(age int){ 
    	p.age = age
    }
    
    func (s *Superman1) print(){ 
    	fmt.Printf("%+v\n",s)
    }

## oop5、接口（多态） ##

package main
    
    import "fmt"
    
    /* 接口 --在go语言中，多态可以直接用接口实现 所谓多态 就是父类的对象可以调用自己不同子类的方法 注意点: 结构体要支持接口，必须将接口内的方法全部实现 说明： 站在接口的层面，任何一个结构体实现了该接口规 定的所有方法，就代表改结构体支持了该接口，反过来如 果一个结构体封装了接口要求的所有方法，该接口的对象 （接口对象为指针类型）可以指向该结构体的对象，此时 可以认为该接口对象就是该结构体对象的指针，此时去调 用接口内的某方法也就是调用该结构体实现的那种同名方 法。 */
    
    func main() { 
    	c1 := Cat{ "white"}
    	d1 := Dog{ "Black"}
    
    	// 定义接口
    	var a1 Animal
    	// 接口指向Cat对象
    	a1 = &c1
    	// 通过接口调用Eat
    	a1.Eat()
    
    	// 接口指向Dog对象
    	a1 = &d1
    	// 通过接口调用Sleep
    	a1.Sleep()
    
    }
    
    type Animal interface { 
    	Sleep()
    	Eat()
    }
    
    type Cat struct { 
    	color string
    }
    
    func (c Cat) Sleep() { 
    	fmt.Printf("%s cat is sleeping\n", c.color)
    }
    
    func (c Cat) Eat() { 
    	fmt.Printf("%s cat is eating\n", c.color)
    }
    
    type Dog struct { 
    	color string
    }
    
    func (d *Dog) Sleep() { 
    	fmt.Printf("%s dog is sleeping\n", d.color)
    }
    
    func (d *Dog) Eat() { 
    	fmt.Printf("%s dog is eating\n", d.color)
    }

> 学通技术，构建可信任社会