通学区块链系列-从go开始之面向对象

Posted 2022-11-24 通学技术

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

我们都知道，这个世界都是有一个个对象构成的，作为要描绘现实世界的编程语言来说，怎么来表征一个对象，显得尤为重要。我们都知道java是通过类的方式来表征对象的，那么go是不是也通过类呢？

答案是否定的。在这里，go继承了c语言的思想，通过结构体来描述对象，做到了原始的纯粹，但同时又加入了继承、封装、多态的思想，使得面向对象得以完善。

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 := Point0.0, 0.0
	p2 := Point3.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)

上面的案例，大家可以自己跟着敲一敲，加深理解。

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