十、面向对象编程_上

10.1 结构体

10.1.1 结构体

看一个问题

10.1.2 一个程序就是一个世界，有很多对象(变量)

10.1.3 Golang语言面向对象编程说明

10.1.4 结构体与结构体变量(实例/对象)的关系示意图

对上图的说明

1、将一类事物的特性提取出来(比如：猫类），形成一个新的数据类型，就是一个结构体

2、通过这个结构体，我们可以创建多个变量(实例对象)

3、事物可以是猫类，也可以是person，也可以是鱼类

10.1.5 快速入门-面向对象的方式(struct)解决养猫的问题

10.1.6 结构体和结构体变量(实例)的区别联系

• 结构体是自定义的数据类型，代表一类事物
• 结构体变量(实例)是具体的，实际的，代表一个具体变量

10.1.7 结构体变量(实例)在内存中的布局—重要

结构体是值类型

10.1.8 如何声明结构体

type 结构体名称 struct {
    field1 type
    field2 type
    .....
}

// 举例

type Cat struct {
	Name string   //Name 大写则表示可以被其他包引用
	Age int 
	Color string
	Hobby string
}

10.1.9 字段/属性

基本介绍

• 从概念或叫法上：结构体=属性=field
• 字段是结构体的一个组成部分，一般是基本数据类型、数组、也可是引用类型，比如我们前面定义猫的结构体的Name string就是属性

注意事项

• 字段声明语法同变量，示例： 字段名 字段类型
• 字段的类型可以为：基本类型、数组或引用类型
• 在创建一个结构体变量后，如果没有给字段赋值，都对应一个零值(默认值)，规则同前面说的一样
• 布尔类型是 false 、整型是 0 、 字符串是 “”
  • 数组类型的默认值和它的元素类型相关，比如：socore [3]int 则为[0,0,0]
  • 指针，slice和map的零值都是nil，即还没有分配空间
• 不同结构体变量的字段是独立的，互不影响，一个结构体变量字段的更改，不影响另外一个，结构体是值类型

上述代码的内存示意图

10.1.10 创建结构体变量和访问结构体字段

10.1.10.1 方式1

直接声明

var person Person

10.1.10.2 方式2

var person Person = Person {}

10.1.10.3 方式3

10.1.10.4 方式4

说明

• 第三种和第四种方式返回的是 结构体指针

• 结构体指针访问字段的标准方式应该是：(*结构体指针).字段名，

  • (*person).Name = "tom"
    

• 但go做了一个简化，也支持 结构体指针.字段名 比如：person.Name = "tom" 更加符合程序员使用的习惯，go编译器底层对 person.Name做了转化(*person).Name

10.1.11 struct类型的E内存分配机制

思考？

变量总是在内存中的，那么结构体变量在内存中究竟是怎样存在的？

结构体在内存中示意图

上述代码内存图

10.1.12 结构体的注意事项和使用细节

1、结构体的所有字段在内存中是连续的

2、结构体是用户单独定义的类型，和其他类型进行转换时需要有完全相同的字段(名字、个数和类型)

3、结构体进行type重新定义(相当于取别名)，Golang认为是新的数据类型，但是相互间可以强转

10.1.13 结构体注意事项

• struct的每个字段上，可以写上一个tag，该tag可以通过反射机制获取，常见的使用场景就是序列号和反序列化

序列化的使用场景

代码

10.2 方法

10.2.1 基本介绍

​ 在某些情况下，我们需要声明/定义(方法)，比如：Person结构体，除了有一些字段外(年龄，姓名...)Person结构体还有一些行为，这时就要用方法才能完成

​ Golang中的方法是作用在指定的数据类型上的(即：和指定的数据类型绑定)，因此自定义类型，都可以有方法。而不仅仅时struct

10.2.2 方法的声明和调用

type A struct {
    Num int
}
func (a A) test() {
    fmt.Println(a.Num)
}

对上面语法的说明

1、func (a A) test() {} 表示A结构体有一方法，方法名为 test

2、(a A) 体现方法是和A类型绑定的

举例

对上面代码说明

1、 test方法和Person类型绑定

2、test方法只能通过Person类型的变量来调用，也不能使用其他类型变量来调用

3、func (p Person) test(){....} p表示哪个Person变量调用，这个p就是它的副本，这点和函数的传参十分相似

4、func (p Person) test(){....} p这个名字，有程序员固定，不是固定不变的

10.2.3 方法快速入门

1、给Person结构体添加 speak方法，输出 xxx是一个好人

2、给Person结构体添加 jisuan方法,可以计算从1+....100的结果，说明方法体内可以函数一样，进行各种运算

3、给Person结构体添加 jisuan2方法，可以接收一个数n，计算从1+...+n的结果

4、给Person结构体添加 getSum方法，可以计算两个数的和，并返回结果

5、方法调用的几种形式

10.2.4 方法的调用和传参机制原理(重要！！)

说明：方法的调用和传参机制和函数基本一样，不一样的地方是方法调用时，会将方法的变量，当作实参也传递给方法

案例1

前面getSum方法的执行过程+说明

上述代码图示

说明

1、在通过一个变量去调用方法时，其调用机制和函数一样

2、不一样的地方是，变量调用方法时，该变量本身也会作为一个参数传递到方法(如果变量是值类型，则进行值拷贝，如果变量是引用类型，则进行地址拷贝)

案例2

编写一个程序，要求如下

• 声明一个结构体Circle，字段为radius
• 声明一个方法area和Circle绑定，可以返回面积

上述代码图示

10.2.5 方法的声明/定义

func (recevier type) methodName (参数列表) (返回值列表) {
    方法体
    return 返回值
}

1、参数列表：表示方法输入
2、recevier type：表示这个方法和type这个类型进行绑定，或者说该方法作用于type类型
3、recevier type：type可以是结构体，也可以是其他的自定义类型
4、receiver：就是type类型的一个变量(实例)，比如：Person结构体的一个变量(实例)
5、返回值列表：表示返回的值，可以多个
6、方法主体：表示为了实现某一功能代码块
7、return ：语句不是必须的

10.2.6 方法注意事项和细节讨论

1、结构体类型是值类型，在方法调用中，遵守值类型的传递机制，是值拷贝传递方式

2、如程序员希望在方法中，修改结构体变量的值，可以通过结构体指针的方式来处理

3、Golang中的方法作用在指定的数据类型上的(即：和指定的数据类型绑定)。。因此自定义类型，都可以有方法，而不仅仅时struct，比如：int float32等都可以有方法

4、方法的访问范文控制的规则，和函数一样，方法名首字母小写，只能在本包访问，方法名大写，可以在本包和其他包访问

5、如果一个类型实现了 String() 这个方法，那么fmt.Println 默认会调用这个变量的String()进行输出

10.2.7 方法练习题

1、编写结构体，编程一个方法，方法不需要参数，在方法中打印一个10*8的矩形，在main方法中调用该方法

2、编写一个方法，提供m和n两个参数，方法中打印一个 m*n的矩形

3、编写一个方法，算该矩形的面积(可以接收长len，和宽width)，将其作为方法返回值，在main方法中调用该方法，接收返回的面积并打印

4、编写一个方法，判断一个数是奇数还是偶数

5、根据行、列、字符打印对应行数和列数的字符，比如：行：3、列：2、字符：*

6、定义小小计算器结构体(Calcuator)，实现加减乘除四个功能

• 实现形式1：分四个方法完成，分别计算 + - * /

package main 
import (
	"fmt"
)
type Calcuator struct {
	Num1 float64
	Num2 float64
}

func (calcuator *Calcuator) getSum() float64 {
	return calcuator.Num1 + calcuator.Num2
}

func (calcuator *Calcuator) jianfa() float64 {
	return calcuator.Num1 - calcuator.Num2
}

func (calcuator *Calcuator) chengfa() float64 {
	return calcuator.Num1 * calcuator.Num2
}

func (calcuator *Calcuator) chufa() float64 {
	return calcuator.Num1 / calcuator.Num2
}

func main() {
	var calcuator Calcuator
	calcuator.Num1 = 1.2
	calcuator.Num2 = 2.2
	fmt.Println("加法=", calcuator.getSum())
	// 下一行的  fmt.Sprintf("%.2f")  是格式化处
	fmt.Printf("减法= %v\n", fmt.Sprintf("%.2f",calcuator.jianfa())) 
	fmt.Println("乘法=", calcuator.chengfa())
	fmt.Println("除法=", calcuator.chufa())
}

• 实现形式2：用一个方法完成 ，需要接收两个数，还有一个运算符

package main 
import (
	"fmt"
)
type Calcuator struct {
	Num1 float64
	Num2 float64
}

func (calcuator *Calcuator) getRes(operator byte) float64 {
	res := 0.0
	switch operator {
	case '+':
			res = calcuator.Num1 + calcuator.Num2
	case '-':
			res = calcuator.Num1 - calcuator.Num2
	case '*':
			res = calcuator.Num1 * calcuator.Num2
	case '/':
			res = calcuator.Num1 / calcuator.Num2
	default:
		fmt.Println("运算符输出有误.....")
	}
	return res
}

func main() {
	var calcuator Calcuator
	calcuator.Num1 = 1.2
	calcuator.Num2 = 2.2
	res := calcuator.getRes('+')
	fmt.Println("res=", res)
}

10.3 方法和函数区别

1、调用方式不一样

​ 函数的调用方式： 函数名(实参列表)

​ 方法的调用方式： 变量.方法名(实参列表)

2、对于普通函数，接受者为值类型时，不能将指针类型的数据直接传递，反之亦然

3、对于方法(如struct的方法)，接收者为值类型时，可以直接用指针类型的变量调用方法，反过来同样也可以

10.4 面向对象编程实例

10.4.1 步骤

• 声明(定义)结构体，确定结构体名
• 编写结构体的字段
• 编写结构体的方法

10.4.2 案例

学生个人信息案例

package main 
import (
	"fmt"
)

type Student struct {
	name string
	gender string
	age int
	id int
	score float64
}

func (student *Student) say() string {
	infoStr := fmt.Sprintf("Student的信息 name=[%v] gender=[%v]  age=[%v] id=[%v] score=[%v]",
	student.name, student.gender, student.age, student.id, student.score)
	return infoStr
}

func main() {
	// 测试
	// 创建一个Student实例变量
	var stu = Student{
		name : "tom",
		gender : "male",
		age : 18,
		id : 10000,
		score : 99.99,
	}
	fmt.Println(stu.say())
}

10.4.3 盒子案例

• 编程创建一个Box结构体，在其中声明三个字段表示一个立方体的长、宽、高、这三者要从终端获取
• 声明一个方法获取立方体的体积
• 创建一个Box结构体变量，打印给定尺寸的立方体的体积

10.4.4 景区门票案例

• 一个景区根据游人的年龄收取不同价格的门票，比如年龄大于18，收费20元，其他情况门票免费
• 请编写Visitor结构体，根据年龄段决定能购买的门票价格并输出

package main 
import (
	"fmt"
)
// 创建一个 Visitor 结构体,定义了长宽高
type Visitor struct {
	Name string
	Age int
}

func (visitor *Visitor) showprice() {
	if visitor.Age > 90 || visitor.Age <= 8 {
		fmt.Println("考虑到安全，请不要去玩耍")
		return
	}
	if visitor.Age > 18 {
		fmt.Printf("游客的名字为%v 年龄为%v  收费20元 \n", visitor.Name, visitor.Age)
	} else {
		fmt.Printf("游客的名字为%v 年龄为%v  免费 \n", visitor.Name, visitor.Age)
	}
}

func main() {
	// 测试
	var v Visitor 
	for {
		fmt.Println("请输入你的名字：")
		fmt.Scanln(&v.Name)
		if v.Name == "n" {
			fmt.Println("谢谢、退出程序")
			break
		}
		fmt.Println("请输入你的年龄：")
		fmt.Scanln(&v.Age)
		v.showprice()
	}
}

10.5 创建结构体变量时指定字段值

​ Golang在创建结构体实例(变量)时，可以直接指定字段的值。

创建结构体变量时指定字段值方式

方式1

package main 
import (
	"fmt"
)

type Student struct {
	Name string
	Age int
}

func main() {
	//方式1
	// 在创建结构体变量时，就直接指定字段的值
	var stu1 = Student{"小明", 19} // stu1 --> 结构体数据空间
	stu2 := Student{"小明~", 22}

	// 方式2
	//  在创建结构体变量时，把字段名和字段值写在一起
	// 这种写法，就不依赖字段的定义顺序
	var stu3 = Student{
		Name : "Jack",
		Age : 9,
	}
	stu4 := Student {
		Age : 30,
		Name : "Marry",
	}

	fmt.Println(stu1, stu2, stu3, stu4)
	fmt.Println()
}

方式2

package main 
import (
	"fmt"
)

type Student struct {
	Name string
	Age int
}

func main() {
	// 方式2 返回结构体的指针类型!!!!!!!!!!
	var stu5 = &Student{"小王", 29} //stu5 --> 地址 --> 结构体数据
	stu6 := &Student{"小王", 33}
	// 在创建结构体指针变量时，把字段名和字段值写在一起
	// 这种写法，就不依赖字段的定义顺序
	var stu7 = &Student {
		Name : "小李",
		Age : 49,
	}
	stu8 := &Student {
		Name : "小李~",
		Age : 49,
	}
	fmt.Println(*stu5, *stu6, *stu7, *stu8)
}

10.6 工厂模式

10.6.1 说明

​ Golang的结构体没有构造函数，通常可以使用工厂模式来解决这个问题。

10.6.2 看一个需求

一个结构体的声明是这样的：

package model
type Student struct {
    Name string....
}

​ 因为这里的Student的首字母S是大写的，如果我们想在其它包创建Student的实例(比如：main包)，引入model包后，就可以直接创建Student结构体的变量，但是问题来了，如果首字母是小写的，比如：type strdent struct {....} 就不行了，怎么办，------> 工厂模式解决

student.go

main.go

如果model包的student 的结构体的字段 Score改成score，我们还能正常访问吗？又该如何解决这个问题？

解决办法