类和对象

• 面向过程编程和面向对象编程主要区别在于思维方式的不同

• 面向过程编程,所有的东西都需要亲力亲为

• 面向对象编程,我们可以把所有事情都可以交给具备了功能的对象完成, 不用亲力亲为

• 在编程开发中如何创建一个对象?(句子中的每个名词,都有机会成为一个对象)
  定义一个类
  通过定义的类创建对象

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

公私有问题

• 只要是大写的就是共有的,只要是小写的都是私有的
• 由于公私有性,让面向对象有了三大特性,封装继承和多态

面向对象-封装性

• 当一个类把自己的成员变量暴露给外部的时候,那么该类就失去对该成员变量的管理权，别人可以任意的修改你的成员变量,所以我们需要封装
• 封装之后: 提供了数据的安全性, 将变化隔离到了自己当中, 外界不用关心内部的处理, 只需要拿到方法使用即可
• 封装的原则: 将不需要对外提供的内容都隐藏起来,把属性都隐藏,提供公共的方法对其访问

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
}

package main

import (
    "demo"
    "fmt"
)
func main()  {
    // 2.通过类创建对象
    p := demo.Person{}
    p.SetName("lnj")
    p.SetAge(-1)
    fmt.Println(p.GetName())
    fmt.Println(p.GetAge())
}

面向对象-继承

• 面向对象的继承性实际上是用结构体的匿名属性实现的

• 继承的规则

  • 子类可以调用父类的方法,子类可以调用父类的属性

  • 子类调用父类的属性和方法需要通过逐级查找

  • 如果子类和父类存在相同的属性和方法,那么采用就近原则,现在子类里找方法,找不到再在父类里找方法(方法重载)

package main

import "fmt"

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()
}

面向对象-多态性

• 多态性其实就是统一事物的不同形态,在代码中的体现就是接口
  • 如果有一只狗,有一只猫,实现了动物的接口,那么那只狗/猫就可以调用自身的属性和方法,也可以调用动物这个类的方法
  • 那么当var dog Dog = Dog{"name":"旺财"}这时候的狗就是狗形态
  • 那么当var animal Animal = Dog{"name":"旺财"}这时候的狗就是动物形态(Animal为接口)

package main

import "fmt"

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

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

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

func main()  {
    //// 1.旺财狗的形态
    var d Dog = Dog{"旺财"}
    d.eat()
    //2.旺财动物的形态
    var a1 Animal = Dog{"旺财"}
    a1.eat()

    var d Dog = Dog{"旺财"}
    eat(d)
}
func eat(a Animal)  {
    a.eat()
}