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

Posted 2021-07-07 通学技术

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

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)
}

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