第十章 Golang面向对象编程（上）-阿里云开发者社区

结构体

看一个养猫问题

张老太养了两只猫猫：一只名字叫小白，今年3岁，白色。还有一只叫小花，今年100岁，花色。请编写一个程序，当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，则显示张老太没有这只猫猫

Golang语言面向对象说明

Golang也支持面向对象（oop），但是和传统的面向对象编程有区别，并不是纯粹面向对象的语言，所以我们说Golang支持面向对象编程特性是比较准确的
Golang没有类（class），Go语言的结构体（struct）和其他编程语言类（class）有同等的地位，你可以理解Golang是基于struct来实现oop特征的。
Golang面向对象编程非常简洁，去掉了传统oop语言的继承，方法重载，构造函数和析构函数，隐藏的this指针等等

结构体与结构体变量（实例/对象）的关系示意图

对上图的说明

将一类事物的特征提取出来，比如说上面的猫猫，有很多属性，形成一个新的数据类型。就是一个结构体。
通过这个结构体，我们可以创建多个变量（实例对象）
事物可以是猫类，也可以是person，fish或是一个工具类

快速入门面向对象的方式（struct）解决养猫问题

代码演示

// 定义一个Cat结构体，将cat的各个字段/属性信息，放入到cat结构体进行管理
type Cat struct {
  Name string
  age int
  Color string
  Hobby string
}
func main(){
  // 创建一个Cat的变量
  var cat1 Cat
  cat1.Name = "小白"
  cat1.Age = 3
  cat1.Color = "白色"
  cat1.Hobby = "吃鱼"
     fmt.Println("cat1=",cat1)
  fmt.Println("猫猫的信息如下：")
  fmt.Println("name=",cat1.Name)
  fmt.Println("Age=",cat1.Age)
  fmt.Println("color=",cat1.Color)
  fmt.Println("hobby=",cat1.Hobby)
}

结构体和结构体变量（实例）的区别和联系

通过上面的案例和讲解我们可以看出：

结构体是自定义的数据类型，代表一类事物
结构体变量（实例）是具体的，实际的，代表一个具体变量
内存展示

如何声明结构体

基本语法

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

举例

type Student struct{
Name string // 字段
Age int // 字段
socure float32
}

字段/属性

基本介绍

从概念或叫法上看，结构体字段 = 属性 = field （即授课中，统一叫字段）
字段是结构体的一个组成部分，一般是基本数据类型，数组，也可是引用数据类型。比如我们前面定义结构体的name string就是属性

注意事项细节说明

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

案例

// 如果结构体的字段类型是：指针，slice，和map的零值都是nil，即还没有分配空间
// 如果需要使用这样的字段，需要先make，才能使用
type Person struct{
  Name string
  Age int
  Scores [5]float64
  ptr *int
  slice []int
  map1 map[string]string
  
}
type Monster struct{
  Name string
  Age int
}
func main(){
  // 定义结构体变量
  var p1 Person
  fmt.Println(p1)
  if p1.ptr == nil{
  fmt.Println("ok1")
  }
  if p1.slice == nil{
  fmt.Println("ok2")
  }
  if p1.map1 == nil{
  fmt.Println("ok3")
  }
  // 使用slice，再次说明，一定要make
  p1.slice = make([]int,10)
  p1.slice[0] = 100
  // 使用map,一定要先make
  p1.map1 = make(map[string]string)
  p1.map1["key1"]= "tom~"
  fmt.Println(p1)
  // 不同结构体变量的字段是独立，互不影响，一个结构体变量字段的改变，不影响另外一个，结构体是值类型
  
  var monster1 Monster
  monster1.Name = "牛魔王"
  monster1.Age = 500
  monster2 := monster1 // 结构体是值类型，默认为值拷贝
  monster2.Name = "狐狸精"
  fmt.Println("monster1=",monster1)
  fmt.Println("monster2=",monster2)
}

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

方式1 直接声明

案例演示：var person Person

前面我们已经说了。

方式2 -{}

案例演示：var person Person = Person {}

方式3-&

案例：var person *Person = new (Person)

方式4-{}

案例：var person *Person = &Person{}

type Person struct{
  Name string
  Age int
}
func main(){
  // 方式1
  // 方式2
  p2 := Person{"mary",20}
  // p2.Name = "tom"
  // p2.Age = 18
  fmt.Println(p2)
  // 方式3-&
  
  // 案例： var person *Person = new (Person)
  var p3 *Person = new(Person)
  //因为p3是一个指针，因此标准的给字段赋值方式
  // (*p3).Name = "smith"也可以这样写 p3.Name = "smith"
  // 原因：go的设计者 为了程序员使用方便，底层会对 p3.Name = "smith" 进行处理会给p3加上 取值运算(*p3).Name = "smith"
  (*p3).Name = "smith"
  p3.Name = "john"
  (*p3).Age = 30
  p3.Age = 100
  fmt.Println(*p3)
  // 方式4-{}
  // 案例：var person *Person = &Person{}
  // 下面的语句，也可以直接给字符赋值
  // var person *Person = &person{"mary",60}
  var person *Person = &Person{}
  // 因为person是一个指针，因此标准的访问字段的方法
  // (*person).Name = "scott"
  // go的设计者为了程序员使用方便，也可以person.Name = "scott"
  // 原因和上面一样，底层会对person.Name = "scott" 进行处理，会加上(*person)
  (*person).Name = "scott"
  person.Name = "scott~~"
  (*person).Age = 88
  personAge = 10
  fmt.Println(*person)
}

说明

第三种和第四种方式的返回值是结构体指针。
结构体指针访问字段的标准方式应该是（*结构体指针）字段名，比如（*person）Name = “tom”
但go做了一个简化，也支持结构体指针字段名，比如 person.Name = “tom”.更加符合程序员使用的习惯。go编辑器底层对person.Name 做了转化（*person）.Name

struct类型的内存分配机制

看一个思考题

我们定义一个Personal结构体（包括名字，年龄）

我们看看下面一段代码，输出什么内容？

var p1 Person
p1.Age = 10
p1.Name = “小明”
var p2 Person = p1
fmt.Println(p2.Age)
p2.name=“tom”
fmt.Printf{“p2.Name=%v p1.Name=%v”,p2.Name,p1.Name}

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

结构体的所有字段在内存中是连续的
结构体是用户单独定义的类型，和其他类型进行转换时需要完全相同的字段（名字，个数和类型）
结构体进行type重新定义（相当于取别名），Golang认为是新的数据类型，但是相互间可以强转
struct的每个字段上，可以写上一个tag，该tag可以通过反射机制获取，常见的使用场景就是序列化和反序列化。

方法

基本介绍

在某些情况下，我们需要声明（定义）方法，比如Person结构体，除了有一些字段外（年龄，姓名…）Person结构体还有一些行为比如：可以说话跑步，通过学习，还可以做算数题，这时就要用方法才能完成。

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

package main
import (
  "fmt"
)
type Person struct{
  Name string
}
func (p Person) test(){
  fmt.Println("test() name=",p.Name)
}
func main(){
  var p Person
  p.Name = "tom"
  p.test() // 调用方法
}

对上面的总结：

test方法和Person类型绑定
test方法只能通过Person类型的变量来调用，而不能直接调用，也不能用其他类型变量来调用
func（p Person）test(){} …p 表示哪个Person变量调用，这个p就是它的副本，这点和函数传参非常类似
p这个名字，由程序员指定，不是固定。比如改成person也是可以

方法的调用和传参机制原理：

说明

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

编写一个程序，要求如下：

声明一个结构体Circle，字段为radius
声明一个方法area和Circle绑定，可以返回面积
提示：画出area执行过程＋说明

方法的声明（定义）

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

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

方法注意事项和细节

结构体类型是值类型，在方法调用中，遵循值类型的传递机制，是值拷贝传递方式
如程序员希望在方法中，修改结构体变量的值，可以通过结构体指针的方式来处理
Golang中的方法作用在指针的数据类型上的（即；和指定的数据类型绑定）
方法的询问范围控制的规则，和函数一样。方法名首字母小写，只能在本包访问，方法首字母大写，可以在本包和其他包访问。
如果一个变量实现了String（）这个方法，那么fmt.Println默认会调用这个变量的String（）进行输出

例子（案例）

package main
import (
 "fmt"
)
type MethodUtils struct{
}
func (mu MethodUtils) Print(){
  for i := 1;i<=10;i++{
    for j:=1;j<=8;j++{
      fmt.Print("*")
    }
    fmt.Println()
  }
}
/**
 编写一个方法提供m和n两个参数，方法中打印一个m*n的矩形
*/
func (mu MethodUtils) Print2(m int,n int){
  for i := 1;i<=m;i++{
    for j:=1;j<=n;j++{
      fmt.Print("*")
    }
    fmt.Println()
  }
}
/**
编写一个方法算该矩形的面积（可以接收长len，和宽width）
将其作为方法返回值，在main方法中调用该方法，接收返回的面积并打印
*/
func (mu MethodUtils) area(len float64,width float64)(float64){
  return len*width
}
func main(){
  /**
  1.编写一个结构体（MethodUtils），编程一个方法，方法不需要参数，在方法中打印一个10*8的矩形，在main方法中调用该方法
  */
  var mu MethodUtils
  mu.Print()
  fmt.Println()
  mu.Print2(5,20)
  areaRes := mu.area(2.5,8.7)
  fmt.Println()
  fmt.Println("面积为=",areaRes)
}

方法和函数的区别

调用方式不一样
函数的调用方式：函数名（实参列表）
方法的调用方式：变量，方法名（实参列表）
对于普通函数，接收者为值类型时，不能将指针类型的数据直接传递，返之亦然
对于方法（如struct的方法），接收者为值类型时，可以直接用指针类型的变量调用方法，反过来同样也可以
总结：
不管调用形式如何，真正决定是值拷贝还是地址拷贝，主要是看这个方法是和那个类型绑定
如果是和值类型，比如（p Person）是值拷贝，如果和指针类型，比如是（p *Person）则是地址拷贝

面向对象编程应用实例

步骤

声明（定义）结构体，确定结构体名
编写结构体的字段
编写结构体的方法

学生案例

编写一个Student结构体，包含name，gender，age，id，score字段，分别为string，string，int，int，float64类型
结构体中声明一个say方法，返回string类型，方法返回信息中包含所有字段值
在main方法中，创建Student结构体实例（变量），并返回信息中包含所有字段值

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:1000,
  score:99.98
   }
   str := stu.say();
   fmt.println(str)
}

1.编程创建一个Box结构体，在其中声明三个字段表示一个立方体的长，宽，高，长宽高要从终端获取

2. 声明一个方法获取立方体的体积

3. 创建一个Box结构体变量，打印给定尺寸的立方体的体积

type Box struct{
  len float64
  width float64
  width float64
}
func (box *Box) getVolumn() float64{
  return box.len * box.width * box.height
}
// 调用
var box Box
box.len = 1.1
box.width = 2.0
box.height = 3.0
volumn := box.getVolumn()
fmt.Printf("体积为=%.2f",volumn)

景区门票案例

一个景区根据游人的年龄收取不同价格的门票，比如年龄大于18，收费20元，其他情况门票免费、
请编写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()
  }
}

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

说明

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

package main 
import (
  "fmt"
)
type Stu struct{
  Name string
  Age int 
}
func main(){
  // 方式1
  // 在创建结构体变量时，就直接指定字段的值
  var stu1 = Stu{"小明",19}
  stu2 := Stu{"小明~",20}
  // 在创建结构体变量时，把字段名和字段值写在一起，这种写法，就不依赖字段的定义顺序
  var stu3 = Stu{
    Name:"jack",
    Age:20
  }
  stu4 := Stu{
    Age:30,
    Name:"mary"
  }
  fmt.Println(stu1,stu2,stu3,stu4)
  
  // 方式2，返回结构体的指针类型（！！！）
   var stu5 *Stu = &Stu{"小王",29}
   stu6 := &Stu{"小王~",30}
   //在创建结构体指针变量时，把字段名和字段值写在一起，这种写法，就不依赖字段的定义顺序
   var Stu7 = &Stu{
    Name:"小李",
    Age:49
  }
  stu8 := &Stu{
    Age:59,
    Name:"小李~"
  }
  fmt.Println(*stu5,*stu6,*stu7,*stu8)
}

工厂模式

说明

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

看一个需求

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

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

package model
// 定义一个结构体
type Student struct{
   Name string
   Score float64
}

package main 
import (
  "fmt"
  "go_code/chapter10/factory/model"
)
func main(){
  // 创建要给Student实例
  var stu = model.Student{
    Name:"tom",
    Score:78.9,
  }
  fmt.Println(stu)
}

改变后

package model
// 定义一个结构体
type Student struct{
   Name string
   score float64
}
// 因为student结构体首字母是小写，因此是只能用在model使用
// 我们通过工厂模式来解决
func NewStudent(n string,s float64) *student{
   return &student{
    Name:n,
    score:s,
  }
}
// 如果score字段首字母小写看，则在其他包不可以直接访问，我们可以提供一个方法
func (s *student) GetScore() float64{
  return s.score
}

package main 
import (
  "fmt"
  "go_code/chapter10/factory/model"
)
func main(){
  // 创建要给Student实例
  //var stu = model.Student{
 //   Name:"tom",
  //  Score:78.9,
  //}
  // 定义student结构体是收字母小写，我们可以通过工厂模式来解决
  var stu = model.NewStudent("tom~~",88.8)
  
  fmt.Println(*stu)
  fmt.Println("name=",stu.Name,"score=",stu.GetScore())
}

感谢观看，我们下次见

第十章 Golang面向对象编程（上）

结构体

Golang语言面向对象说明

结构体与结构体变量（实例/对象）的关系示意图

快速入门面向对象的方式（struct）解决养猫问题

结构体和结构体变量（实例）的区别和联系

如何声明结构体

字段/属性

基本介绍

注意事项细节说明

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

struct类型的内存分配机制

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

方法

方法的调用和传参机制原理：

方法的声明（定义）

方法注意事项和细节

方法和函数的区别

面向对象编程应用实例

景区门票案例

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

工厂模式

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

第十章 Golang面向对象编程（上）

结构体

Golang语言面向对象说明

结构体与结构体变量（实例/对象）的关系示意图

快速入门 面向对象的方式（struct）解决养猫问题

结构体和结构体变量（实例）的区别和联系

如何声明结构体

字段/属性

基本介绍

注意事项细节说明

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

struct类型的内存分配机制

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

方法

方法的调用和传参机制原理：

方法的声明（定义）

方法注意事项和细节

方法和函数的区别

面向对象编程应用实例

景区门票案例

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

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

快速入门面向对象的方式（struct）解决养猫问题