//类型定义
type Preson struct {
    name string
}
//类型方法
func (p *Person) SetName(name string) {
    p.name = name
}

//类型方法
func (p *Person) GetName() string {
    return p.name
}

//工厂方法
func NewPerson(name string) *Person{
    p := new(Person)
    p.SetName(name)
    return p
}

//获取person类型的值指针
p := NewPerson("name")
fmt.Println(p.GetName())

type Preson struct {
    Name string
    age int
}
func (p *Person) SetAge(age int){
    p.age = age
}

//嵌入
type Student1 struct {
    Person //匿名字段为嵌入类型
    School string
}

//聚合
type Student2 struct {
    Ps     Person //命名字段为聚合类型
    School string
}

func OOPDemo() {
    s1 := new(Student1)
    s1.Name = "fun1" //嵌入的类型可直接使用其内部属性，更像继承
    s1.School = "Social University1"
    s1.SetAge(18) //可以直接使用Person的方法

    s2 := new(Student2)
    s2.Ps.Name = "fun2" //聚合的类型需要先访问属性值名，在访问属性值内部的属性
    s2.School = "Social University2"
    s1.Ps.SetAge(18) //可以间接使用Person的方法
    
    //OUTPUT:
    //s1: &{{fun1} Social University1}
    //s2: &{{fun2} Social University2}
}

//接口
type IPerson interface {
    SetName(string)
    GetName() string
}
//自定义函数
type MyFuncType func(int) int

//大杂烩结构体
type Something struct {
    a   int         //基本数据类型
    b   []byte      //切片
    p   Person      //结构体
    s   *Student    //指针
    i   IPerson     //接口
    f   MyFuncType  //自定义函数类型
    any interface{} //任意类型
}

//类型定义
type Preson struct {
    name string
}
//类型方法，接收者为该类型的指针
func (p *Person) SetName(name string) {
    p.name = name
}
//类型方法，接收者为该类型的值
func (p Person) GetName() string {
    return p.name
}

//调用示例
p := new(Person)
//SetName()方法接收者为指针，使用指针类型或值类型去调用都可以
p.SetName("fun") //可以
*p.SetName("func") //指针取值后再去调用也可以。

//GetName()方法接收者为值类型，所以调用该方法只能为值
p.GetName() //不可以
*p.GetName() //可以

type Preson struct {
    Name string  //外部可见并可修改
    age int //仅内部可见内部方法修改
}

//类型方法，外部可见
func (p *Person) SetAge(age int) {
    //调用内部方法
    p.setage(name)
}
//类型方法，内部可见
func (p *Person) setage(age int) {
    p.age = age
}

//任何实现了IAnimal签名方法的类型都属于IAnimal类型
type IAnimal interface {
    Live()
    Dead()
}

//Humen结构体
type Monkey struct {}
func (m *Monkey) Live() {
    fmt.Println("猴子活着吃香蕉！！！")
}
func (m *Monkey) Dead() {
    fmt.Println("香蕉有毒，猴子死了！！！")
}
//Cat结构体
type Cat struct {}
func (c *Cat) Live() {
    fmt.Println("猫活着吃鱼！！！")
}
func (c *Cat) Dead() {
    fmt.Println("猫吃了河豚死翘翘！！！")
}

//演示：
//声明一个IAnimal的切片
 var zoo []IAnimal 
func addAnimal(animal IAnimal) {
    zoo = append(zoo,animal)
}
func OOPDemo02(){
    m := new(Monkey)
    c := new(Cat)
    addAnimal(m)
    addAnimal(c)
    
    //遍历
    for _,animal := range zoo {
        animal.Live()
        animal.Dead()
    }
}

//OUTPUT:
//猴子活着吃香蕉！！！
//香蕉有毒，猴子死了！！！
//猫活着吃鱼！！！
//猫吃了河豚死翘翘！！！

type IPerson interface{
    GetName()
    SetName()
}

//任何实现GetName()、SetName()方法的类型都可赋值给person
var person IPerson


接口类型赋值给另一接口类型

type Writer interface{    //父接口
    Write(buf []byte) (n int,err error)
}
type ReadWriter interface{    //子接口
    Read(buf []byte) (n int,err error)
    Write(buf []byte) (n int,err error)
}
var file1 ReadWriter=new(File)   //子接口实例
var file2 Writer=file1           //子接口实例赋值给父接口

//该类型实现了标准包的io.Writer接口
type F struct {}

func (f *F) Write(p []byte) (n int, err error) {
    //block
}

//生物接口
type IBeing interface{
    Live()
    Dead()
}
//动物接口嵌入生物接口
type IAnimal interface {
    IBeing
    Hunting()
}
//植物接口嵌入生物接口
type IPlant interface {
    IBeing
    Growing()
}

type Tiger struct {}
func (t *Tiger) Live() {
    fmt.Println("老虎活着称大王！！！")
}
func (t *Tiger) Dead() {
    fmt.Println("老虎战斗死了！！！")
}
func (t *Tiger) Hunting() {
    fmt.Println("老虎捕猎！！！")
}

type Flower struct{}
func (t *Flower) Live() {
    fmt.Println("花儿享受阳光！！！")
}
func (t *Flower) Dead() {
    fmt.Println("花儿落下死了！！！")
}
func (t *Flower) Growing() {
    fmt.Println("花儿茁壮成长！！！")
}


//声明一个interface{}的切片
var earth []interface{}

func addBeing(b interface{}) {
    earth = append(earth, b)
}
func OOPDemo03() {
    tiger := new(Tiger)
    flower := new(Flower)
    addBeing(tiger)
    addBeing(flower)

    //遍历
    for _, being := range earth {
        if animal, ok := being.(IAnimal); ok {
            animal.Live()
            //如果是动物则捕猎
            animal.Hunting()
            animal.Dead()
        }
        if plant, ok := being.(IPlant); ok { 
            plant.Live()
            //如果是植物则成长
            plant.Growing()
            plant.Dead()

        }

    }
}

//OUTPUT:
//老虎活着称大王！！！
//老虎捕猎！！！
//老虎战斗死了！！！

//花儿享受阳光！！！
//花儿茁壮成长！！！
//花儿落下死了！！！

//试着转一下类型,不成功也不会报错
plant, ok := being.(IPlant)

//转一下类型,不成功就会panic
plant := being.(IPlant)

fei@feideMacBook-Pro faceinter % tree ./
./
├── app
│   └── app.go
├── data
│   └── data.go
└── main.go

//data层
package data

import "fmt"

type Sql interface {
	Open() error
}

type mysql struct {
	url string
}

func Newmysql(url string) *mysql {
	return &mysql{url: url}
}

func (sql *mysql) Open() error {
	fmt.Println("打开了", sql.url)
	return nil
}

type mgdb struct {
	url string
}

func Newmgdb(url string) *mgdb {
	return &mgdb{url: url}
}

func (sql *mgdb) Open() error {
	fmt.Println("打开了", sql.url)
	return nil
}

//app层
package app

import (
	"faceinter/data"
	"fmt"
)

type App interface {
	Sum(int, int) int
}

type app struct {
	mydesql data.Sql //依赖interface类型
}

func NewAppIns(mydesql data.Sql) App { //不依赖具体实现将mydesql字段当作依赖传递进来
	return &app{
		mydesql: mydesql,
	}
}

func (app1 *app) Sum(a, b int) int {
	err := app1.mydesql.Open()
	if err != nil {
		panic(err)
	}
	fmt.Printf("%v + %v = %v\n", a, b, a+b)
	return a + b
}

//main.go
package main

import (
	"faceinter/app"
	"faceinter/data"
)

// 依赖定义的接口而不依赖实现
func callAppFunc(ap app.App) {
	ap.Sum(1, 2)
}

func main() {
	newsql := data.Newmgdb("127.0.0.1:27017")
	appins := app.NewAppIns(newsql) //app层依赖data层，通过data层私有构造函数做依赖注入

	//将实现传递进去
	callAppFunc(appins)
}


OUTPUT：
打开了 127.0.0.1:27017
1 + 2 = 3

~/go/src/go-interface main !1 ?1 ❯ go run ./
2024/06/28 18:03:05 召回hot耗时0ms，召回了5个商品
2024/06/28 18:03:05 召回szie耗时0ms，召回了8个商品
2024/06/28 18:03:05 去重之后一共召回了8个商品
2024/06/28 18:03:05 排序耗时0ms
2024/06/28 18:03:05 过滤规则ratio耗时0ms，过滤掉了4个商品
No.0,Id:7,Name:p7
No.1,Id:1,Name:p1
No.2,Id:2,Name:p2
No.3,Id:3,Name:p3