package main

import "fmt"

/*
  oop--面向对象 自定义结构
  现代编程，都讲究面向对象编程 作为一门比较潮的go语言来说
  面向对象自然也是支持的 而面向对象的三要素分别是
  封装、继承、多态
  然我们来看看go是怎么玩转他们的吧
 */

// 首先我们的go 忽略了class的概念 转而用结构体来声明对象
/*
  说明: Go语言作为一门基于包管理的开发语言
如果想将自己的结构体作为公共包被其他包导入，需
要将结构体的首字母大写，同样地，结构体内部的字
段和函数希望被外部包访问也需要将首字母大写。
*/
type Person struct {
  name string
  age int
  sex string
  // 战斗力
  fight int
}

func main(){
  // 定义并初始化
  p1 := Person{"渣渣辉",30,"man",5}
  fmt.Println(p1)

  // 先定义后赋值
  var p2  Person
  p2.age = 10
  p2.name = "胖渣渣"
  p2.sex = "woman"
  // +v的打印方式 可以更详细地显示结构体内容
  fmt.Printf("%+v\n",p2)

}

package main

import (
  "fmt"
  "math"
)

// 当整个世界都说你不行的时候 你必须要大声地对他们说 我行
/*
  封装:
    1.在结构体外部定义
    2.方法一定要体现出调用者，方法只能被调用者类型的对象调用

  格式：
    func (obj objT) funcName([params list] [return list])

 */
func main() {
  p1 := Point{0.0, 0.0}
  p2 := Point{3.0,4.0}
  fmt.Println(getDis(p1,p2))
  fmt.Println(p2.getDis2(p1))
}

type Point struct {
  x, y float64
}

func getDis(p1, p2 Point) float64 {
  return math.Sqrt((p2.x-p1.x)*(p2.x-p1.x) + (p2.y-p1.y)*(p2.y-p1.y))
}

// 只能被Point类型的对象调用
func (this Point) getDis2(p Point) float64 {
  return math.Sqrt((this.x-p.x)*(this.x-p.x) + (this.y-p.y)*(this.y-p.y))
}

package main

import "fmt"

/**
  结构体内嵌
  说明：
    我们都知道 在面向对象的世界里，有两种主要模式
    一种是我们所说的继承 而另外一种就是我们就是我们的组合
    例如，儿子会继承爸爸的财产，他们都同事继承人的普遍特性吃喝拉撒
    而人都是有手脑眼口鼻等这些对象组合而成的
 */

// 组合或类型表征
func main(){
  p1 := Person1{"渣渣辉",30,"man",5}
  s1 := Superman{
    strength: 100000,
    speed: 19000,
    p:p1,//逗号必须有
  }
  s1.p.setAge(40)
  s1.print()
}

// 同包下 结构体名称不能相同
type Person1 struct{
  name string
  age int
  sex string
  fright int
}

// 引用类型
func (p *Person1) setAge(age int){
  p.age = age
}
// 超人也具有人的特性
type Superman struct{
  strength int
  speed int
  p Person1
}

func (s Superman) print(){
  fmt.Printf("%+v\n",s)
}

package main

import "fmt"

/**
    结构体内嵌(embed)
    --go中没有类似于java的extends、solidity的is这类直接表征继承的关键字
    而是采用了更为直接的方式 内嵌
 */

func main(){

    p1 := Person2{"渣渣辉",30,"man",5}
    s1 :=Superman1{
        strength: 100000,
        speed: 9000,
        // 正确的写法
        Person2 : p1,
    }
    // 子类直接调用父类的方法 继承财产、能力、品性更直接更方便啦
    s1.setAge(50)
    s1.print()

}

type Person2 struct {
    name string
    age int
    sex string
    fight int
}

type Superman1 struct {
    strength int
    speed    int
    // 结构体内嵌的写法
    Person2
}

func (p *Person2) setAge(age int){
    p.age = age
}

func (s *Superman1) print(){
    fmt.Printf("%+v\n",s)
}

package main

import "fmt"

/*
    接口
    --在go语言中，多态可以直接用接口实现
    所谓多态 就是父类的对象可以调用自己不同子类的方法
    注意点:
        结构体要支持接口，必须将接口内的方法全部实现
    说明：
        站在接口的层面，任何一个结构体实现了该接口规
    定的所有方法，就代表改结构体支持了该接口，反过来如
    果一个结构体封装了接口要求的所有方法，该接口的对象
    （接口对象为指针类型）可以指向该结构体的对象，此时
    可以认为该接口对象就是该结构体对象的指针，此时去调
    用接口内的某方法也就是调用该结构体实现的那种同名方
    法。
*/

func main() {
    c1 := Cat{"white"}
    d1 := Dog{"Black"}

    // 定义接口
    var a1 Animal
    // 接口指向Cat对象
    a1 = &c1
    // 通过接口调用Eat
    a1.Eat()

    // 接口指向Dog对象
    a1 = &d1
    // 通过接口调用Sleep
    a1.Sleep()

}

type Animal interface {
    Sleep()
    Eat()
}

type Cat struct {
    color string
}

func (c Cat) Sleep() {
    fmt.Printf("%s cat is sleeping\n", c.color)
}

func (c Cat) Eat() {
    fmt.Printf("%s cat is eating\n", c.color)
}

type Dog struct {
    color string
}

func (d *Dog) Sleep() {
    fmt.Printf("%s dog is sleeping\n", d.color)
}

func (d *Dog) Eat() {
    fmt.Printf("%s dog is eating\n", d.color)
}