前言

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是断言的类型