1.面向对象:

// 1.定义一个类
type Person struct {
   name string // 属性
   age int
}
// 行为
func (p Person)say()  {
   fmt.Println(p.name, p.age)
}
func (p Person)eat()  {
   fmt.Println(p.name, "正在吃饭")
}
func main() {
    // 根据定义好的类创建一个对象
    per := Person{"lnj", 33}
    per.say()
    per.eat()
}复制代码

总结:

1.什么是面向过程?
强调的是功能行为
   关注的是解决问题需要哪些步骤
所有事情都需要亲力亲为

2.什么是面向对象?
强调具备了功能的对象
  关注的是解决问题需要哪些对象
所有事情都可以交给具备了功能的对象完成, 不用亲力亲为

3.在编程开发中如何创建一个对象?
3.1定义一个类
3.2通过定义的类创建对象

现实生活中要创建一个对象, 必须现有一个模型
例如: 生产汽车, 必须有图纸, 然后再根据图纸生产出具体的汽车
现实生活中的图纸, 就是用于描述汽车有哪些属性和行为
在编程中, 要想创建对象, 必须先有类
编程中的类和现实生活中的图纸一样, 也是用于描述将来创建出来的对象有哪些属性和行为

4.如何定义一个类
在类中说明有哪些属性和行为, 在Go语言中可以通过结构体来说明有哪些属性和行为
结构体的属性 就是用于说明 属性的
结构体的方法 就是用于说明 行为的复制代码

2.封装性:

package demo

// 1.定义一个类
type Person struct {
   //Name string
   //Age int
   name string
   age int
}
// 提供了两个对外的接口
// 本质就是对外提供了两个公有的方法
func (p *Person)SetName(name string)  {
   p.name = name
}
func (p *Person)SetAge(age int)  {
   // 可以对外界的修改进行逻辑判断处理
   if age < 0 {
      age = 0
   }else if(age > 100){
      age = 100
   }
   p.age = age
}
func (p *Person)GetName() string  {
   return p.name
}
func (p *Person)GetAge() int  {
   return p.age
}复制代码
func main()  {
   // 2.通过类创建对象
   p := demo.Person{}
   //p.name = "lnj"
   // 当一个类把自己的成员变量暴露给外部的时候,那么该类就失去对该成员变量的管理权，别人可以任意的修改你的成员变量
   //p.age = -1

   // 封装之后: 提供了数据的安全性, 将变化隔离到了自己当中, 外界不用关心内部的处理, 只需要拿到方法使用即可
   // 封装的原则: 将不需要对外提供的内容都隐藏起来,把属性都隐藏,提供公共的方法对其访问
   p.SetName("lnj")
   p.SetAge(-1)
   fmt.Println(p.GetName())
   fmt.Println(p.GetAge())
}复制代码

3.继承性:

type Person struct {
   name string
   age int
}
func (p *Person)say()  {
   fmt.Println(p.name, p.age)
}

// Go语言中的继承就是通过匿名属性来实现的
type Student struct {
   Person // 匿名属性
   score int
}
func (stu *Student)say()  {
   fmt.Println(stu.name, stu.age, stu.score)
}

func main()  {
   // 总结:
   // 子类可以使用父类的属性和方法
   // 如果子类和父类出现了重名的属性, 那么采用就近原则
   // 如果子类和父类出现了重名的属性, 要想访问父类的属性, 必须逐级查找
   // 如果子类和父类出现了重名的方法, 那么采用就近原则 (方法重载)
   // 如果子类和父类出现了重名的方法, 要想访问父类的方法, 必须逐级查找 (方法重载)
   stu := Student{}
   // 属性的继承
   stu.name = "zs"
   stu.age = 18
   stu.score = 66
   //fmt.Println(stu)
   // 方法的继承
   stu.say()
   stu.Person.say()
}复制代码

4.多态性:

// 1.定义一个接口
type Animal interface {
   eat()
}
type Dog struct {
   name string
}

func (d Dog)eat()  {
   fmt.Println(d.name, "吃东西")
}

// 3.定义一个猫的结构体
type Cat struct {
   name string
}

func (c Cat)eat()  {
   fmt.Println(c.name, "吃东西")
}

func main()  {
   /*
   1.什么是多态?
   多态就是某一类事物的多种形态

   2.在Go语言中通过接口来实现多态
    */
    1.666的int形态
   //var num int = 666
    2.66的接口形态
   //var value interface{} = 666


    1.旺财狗的形态
   //var d Dog = Dog{"旺财"}
   //d.eat()
    2.旺财动物的形态
   //var a1 Animal = Dog{"旺财"}
   //a1.eat()
   //
    1.外星人猫的形态
   //var c Cat = Cat{"外星人"}
   //c.eat()
    2.外星人动物的形态
   //var a2 Cat = Cat{"外星人"}
   //a2.eat()

   var d Dog = Dog{"旺财"}
   var c Cat = Cat{"外星人"}
   eat(d)
   eat(c)
}
func eat(a Animal)  {
   a.eat()
}复制代码

代码https://github.com/codeXiaoQiang/Go-language