前言

Go也有面向对象

面向对象引入:

用面向对象好啊

结构体定义

GO中的结构体和其他语言中的class是同一个等级的

这个就懒得写了 , 直接贴一个

内存分析

当实例化一个结构体的时候,分配一份内存空间.

结构体实例的创建

package main  import "fmt"  type Teacher struct {  Name   string  age    int  School string  
}  func main() {  // 实例化方法一:  var t1 Teacher // var a int  fmt.Println(t1)  // 实例化方法二:  var t2 Teacher = Teacher{  Name:   "simple",  age:    0,  School: "ssss",  }  // 实例化方法三:  var t3 Teacher = Teacher{}  t3.age = 10  //实例化方法四:  //t4是一个指针,t4其实指向的就是地址, 应该给这个地址的指向的对象的字段赋值.  var t4 *Teacher = new(Teacher)  (*t4).Name = "simple"  (*t4).age = 24  // 为了符合程序员的编程习惯,go提供了简单的赋值方式  t4.Name = "sim"  t4.age = 25  // 实例化方式五:  var t5 *Teacher = &Teacher{}  (*t5).Name = "simple"  (*t5).age = 11  t5.School = "ajglajgl"  
}

五种方式的实例化

结构体之间的转换:

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

package main  import "fmt"  type Student struct {  age int  
}  type Person struct {  age int  
}  func main() {  var s Student = Student{age: 10}  var p Person = Person{age: 10}  s = Student(p)  fmt.Println(s)  fmt.Println(p)  }

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

package main  import "fmt"  type Student struct {  age int  
}  type Stu Student  func main() {  var s1 Student  var s2 Stu  s1 = Student(s2)  fmt.Println(s1)  fmt.Println(s2)  }

也就是都要在结构体完全相同的情况下可以进行强转

方法:

上面的结构体绑定方法是用的值传递
用视频中的例子来解释

package main  type Boy struct {  Name string  
}  func (b Boy) tets() {  b.Name = "complex"  println("方法")  println(b.Name)  
}  func main() {  var boy Boy  boy.Name = "simple";  boy.tets()  println(boy.Name)  }

在方法中去更改Name的值,只是更改了传给方法的结构体的副本的值, 但是原本的结构体并没有被更改.

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

如果程序员希望在方法中,改变了结构体中字段的值, 原来的结构体中的值也被改变,就需要用引用传递的方式来绑定变量了

其实上面的也就是值方法和指针方法的区别
https://zhuanlan.zhihu.com/p/101363361
下面就将上面的值方法改陈指针方法:

package main  type Boy struct {  Name string  
}  func (b *Boy) tets() {  b.Name = "complex"  println("方法")  println(b.Name)  
}  func main() {  var boy Boy  boy.Name = "simple"  boy.tets()  println(boy.Name)  }

指定数据类型的方法

package main  type integer int  func (i integer) print() {  print("wuwuwuwu")  
}  func main() {  var i integer = 1  i.print()  }

方法的访问控制规则

是和函数一样的,如果首字母小写,只能在本包进行访问, 如果首字母大写了,就可以在其他包中进行访问.

方法的trick

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

package main  import "fmt"  type Animal struct {  name string  age  int  
}  func (a *Animal) String() string {  str := fmt.Sprintf("name = %v , age = %v", a.name, a.age)  return str  
}  
func main() {  animal := Animal{  name: "cat",  age:  11,  }  //传入地址,如果绑定了String方法就会自动调用了  fmt.Println(&animal)  
}

类似Java中的toString方法
在定义结构体的时候,可以把这个方法定义好,常用来作为输出结构体信息的方法

跨包创建结构体示例

这里的结构体名首字母大写,字段名首字母也要大写,否则没法被外部包访问.

工厂模式

上面我们知道,要外部包访问结构体,结构体名首字母必须大写,但是如果小写了,我还是想访问,怎么办?
这里就出现了工厂模式

可是无论怎么样,在结构体中,字段名的首字母都要大写.
通过调用函数来返回结构体指针.

封装的引入

什么是封装:

封装就是把抽象的字段和对字段的操作封装到一起,数据被保护在内部,程序的其他包通过授权的操作方法,才能对字段进行操作.

封装的好处:

• 隐藏实现细节
• 提高对数据的验证,保证安全性

如何实现:

• 建议将结构体,字段的首字母小写(其他包就不能使用了,类似于private)
• 给结构体所在的包提供一个工厂模式的函数,首字母小写(类似一个构造函数)
• 提供一个首字母大写的Set方法(类似其他语言的public),用于对属性的判断和赋值
• 提供一个首字母大写的Get方法(类似其他语言的public),用于获取属性的值
  Go的封装不是很严格

package student  type person struct {  Name string  age  int //其他包不能访问  
}  // 定义工厂模式的函数,相当于构造器  
func NewPerson(name string) *person {  return &person{  Name: name,  }  
}  // 定义Set和Get方法对字段进行封装,  
func (p *person) SetAge(age int) {  if age > 0 && age < 120 {  p.age = age  } else {  print("输入不合法")  }  }  func (p *person) GetAge() int {  return p.age  
}

这里的person中的两个字段,一个是首字母大写的, 一个是全小写的,Name就可以用工厂模式来弄,而age就只能通过方法来弄了

继承:

多个结构体存在相同属性,可以吧这些结构体中抽象出一个结构体,该结构体中定义这些相同的字段,其他结构体就可以不用重复写这些字段了.
在GO中,其他结构体不用重新定义这些属性和方法了,只需要嵌套一个匿名结构体就行.

这些继承,父类,子类被Go语言弱化了,但是写代码过程中思维要清楚

上面就是匿名结构体实现继承的图解释.

代码展示一下:

package main  import "fmt"  type Animal struct {  Age    int  Weight float32  
}  // Animal的方法:  
func (a *Animal) Shout() {  fmt.Println("叫")  
}  func (a *Animal) ShowInfo() {  fmt.Println(a.Age, a.Weight)  
}  //定义猫的结构体  
type Cat struct {  // 继承:用匿名结构体来做  Animal  
}  //Cat 的方法  func (c *Cat) Scratch() {  fmt.Println("猫的爪子")  
}  func main() {  cat := &Cat{Animal{  Age:    10,  Weight: 10,  }}  cat.Animal.Age = 11  cat.Animal.Weight = 11  cat.Animal.Shout()  cat.Animal.ShowInfo()  cat.Scratch()  }

注意事项:

其实都是比较好理解的,就不做code了

第五个如果不做区分是会报错的

第六个

组合类型

这个组合类型不是继承关系

接口:

package main  import (  "fmt"  
)  //定义一个接口:接口一些规则,规范,某种能力  
//这里是抽象理解一个说你好的能力  
type Sayhello interface {  //声明一个没有实现的方法  Sayhello()  
}  //接口的实现:定义一个结构体  
//中国人:  
type Chinese struct {  
}  //实现接口的方法  
func (c *Chinese) Sayhello() {  fmt.Println("你好")  
}  type English struct {  
}  func (e *English) Sayhello() {  println("hi")  
}  func main() {  chinese := &Chinese{}  chinese.Sayhello()  english := English{}  english.Sayhello()  
}

你好
hi

所以就是如果一个结构体实现了接口中的所有定义的方法,这个结构体就实现了这个接口.

看看这个接口可做什么?

package main  import (  "fmt"  
)  // 定义一个接口:接口一些规则,规范,某种能力  
// 这里是抽象理解一个说你好的能力  
type Sayhello interface {  //声明一个没有实现的方法  Sayhello()  
}  // 接口的实现:定义一个结构体  
// 中国人:  
type Chinese struct {  
}  // 实现接口的方法  
func (c *Chinese) Sayhello() {  fmt.Println("你好")  
}  type English struct {  
}  func (e *English) Sayhello() {  println("hi")  
}  // 定义一个函数:用来专门向各个国家的人打招呼的函数,接收具备Sayhello接口的能力的变量  
func greet(s Sayhello) {  s.Sayhello()  
}  func main() {  chinese := &Chinese{}  chinese.Sayhello()  english := &English{}  english.Sayhello()  greet(chinese)  greet(english)  }

接口是一个隐式的实现.
要求并不严格
接口的目的是为了让定义规范
其实也和下面的多态有关系

多态

基本介绍:

变量(实例)具有多种形态.面向对象的第三大特征, 在Go中,多态是通过接口来实现的.
可以按照统一的接口来调用不同的实现. 这时接口变量就呈现不同的形态.

案例

就是上面接口中的不同国家的人的打招呼

package main  import (  "fmt"  
)  // 定义一个接口:接口一些规则,规范,某种能力  
// 这里是抽象理解一个说你好的能力  
type Sayhello interface {  //声明一个没有实现的方法  Sayhello()  
}  // 接口的实现:定义一个结构体  
// 中国人:  
type Chinese struct {  
}  // 实现接口的方法  
func (c *Chinese) Sayhello() {  fmt.Println("你好")  
}  type English struct {  
}  func (e *English) Sayhello() {  println("hi")  
}  // 定义一个函数:用来专门向各个国家的人打招呼的函数,接收具备Sayhello接口的能力的变量  
func greet(s Sayhello) {  s.Sayhello()  
}  func main() {  chinese := &Chinese{}  english := &English{}  greet(chinese)  greet(english)  }

接口体现多态特征

• 多态参数:
  

• 多态数组
  

断言

什么是断言:

Go语言里面有一个语法,可以直接判断是否是该类型的变量:value , ok = element.(T), 这里的value就是变量的值, ok是一个bool类型, element是interface变量, T是断言的类型