十一、面向对象（二）

01 结构体嵌套

package main
import (
    "fmt"
    "unsafe"
)
//结构体不允许嵌套结构体本身
//可以嵌套结构体本身指针
//链表的数据存储格式
//线性存储  链式存储  树式存储 图式存储
type student struct {
    *student
    name string
    age int
    sex string
}
func main(){
    //var stu student
    var a string="sdfhjsd"
    //计算数据类型在内存中占的字节大小
    fmt.Println(unsafe.Sizeof(a))
    fmt.Println(len(a))
    //stu.name="张三"
    //
    //fmt.Println(stu)
}

02 面向对象计算器实现

package main

import "fmt"

//定义接口
type Opter interface {
    //方法声明
    Result() int
}

//父类
type Operate struct {
    num1 int
    num2 int
}

//加法子类
type Add struct {
    Operate
}

//减法子类
type Sub struct {
    Operate
}

//乘法子类
type Mlt struct {
    Operate
}

//工厂类
type Factory struct {
}

//加法子类的方法
func (a *Add) Result() int {
    return a.num1 + a.num2
}

//减法子类的方法
func (s *Sub) Result() int {
    return s.num1 - s.num2
}

//乘法子类的方法
func (m *Mlt) Result() int {
    return m.num1 * m.num2
}

//多态实现
func Result(o Opter) {
    value := o.Result()
    fmt.Println(value)
}
func (f *Factory) Result(num1 int, num2 int, ch string) {
    switch ch {
    case "+":
        var a Add
        a.num1 = num1
        a.num2 = num2
        Result(&a)
    case "-":
        var s Sub
        s.num1 = num1
        s.num2 = num2
        Result(&s)
    case "*":
        var m Mlt
        m.num1 = num1
        m.num2 = num2
        Result(&m)
    }
}

//通过设计模式调用
func main() {
    //创建工厂对象
    var f Factory
    f.Result(10, 20, "*")
}

//多态调用
func main0203() {
    //var a Add = Add{Operate{10, 20}}
    var s Sub = Sub{Operate{10, 20}}
    Result(&s)
}

//接口调用
func main0202() {
    var o Opter
    var a Add = Add{Operate{10, 20}}

    o = &a
    value := o.Result()
    fmt.Println(value)

}

//方法调用
func main0201() {
    //创建加法对象
    //var a Add
    //a.num1 = 10
    //a.num2 = 20
    //v := a.Result()
    //fmt.Println(v)

    //创建减法对象
    var s Sub
    s.num1 = 10
    s.num2 = 20
    v := s.Result()
    fmt.Println(v)
}

03 接口定义和使用

package main

import "fmt"

//先定义接口  在根据接口实现功能
type Humaner interface {
    //方法  方法声明
    SayHello()
    //Result(int, int) int
}

type Student struct {
    name  string
    age   int
    sex   string
    score int
}

type Teacher struct {
    name    string
    age     int
    sex     string
    subject string
}

func (s *Student) SayHello() {
    fmt.Printf("大家好，我是%s，我今年%d岁，我是%s生，我的成绩是%d分\n",
        s.name, s.age, s.sex, s.score)
}

func (t *Teacher) SayHello() {
    fmt.Printf("大家好，我是%s，我今年%d岁，我是%s生，我的学科是%s\n",
        t.name, t.age, t.sex, t.subject)
}

func main() {
    //接口是一种数据类型 可以接收满足对象的信息
    //接口是虚的  方法的实的
    //接口定义规则  方法实现规则
    //接口定义的规则 在方法中必须有对应的实现
    var h Humaner

    //对象创建
    stu := Student{"小明", 18, "男", 99}
    //stu.SayHello()
    //将对象信息赋值给接口类型变量
    h = &stu
    h.SayHello()

    tea := Teacher{"法师", 31, "男", "go语言与区块链"}
    //tea.SayHello()
    //将对象赋值给接口 必须满足接口中方法的声明格式
    h = &tea
    h.SayHello()
}

04 多态的实现

package main

import "fmt"

//先定义接口  在根据接口实现功能
type Humaner1 interface {
    //方法  方法声明
    SayHello()
    //Result(int, int) int
}

type Student1 struct {
    name  string
    age   int
    sex   string
    score int
}

type Teacher1 struct {
    name    string
    age     int
    sex     string
    subject string
}

func (s *Student1) SayHello() {
    fmt.Printf("大家好，我是%s，我今年%d岁，我是%s生，我的成绩是%d分\n",
        s.name, s.age, s.sex, s.score)
}

func (t *Teacher1) SayHello() {
    fmt.Printf("大家好，我是%s，我今年%d岁，我是%s生，我的学科是%s\n",
        t.name, t.age, t.sex, t.subject)
}

//多态的实现
//将接口作为函数参数  实现多态
func SayHi(h Humaner1){
    h.SayHello()
}

func main() {

    stu:=Student1{"小明",18,"男",99}
    //调用多态函数
    SayHi(&stu)

    //tea:=Teacher1{"法师",31,"男","go"}
    //SayHi(&tea)

}

05接口编程

package main

import "fmt"

//定义接口
type inter interface {
    //通信接口
    CSocketProtocol()
    //加密接口
    CEncDesProtocol()
}

//厂商1类
type CSckImp1 struct {
    data   string
    socket string
}

//厂商2类
type CSckImp2 struct {
    data   string
    socket string
    value int
}

func (cs1 *CSckImp1) CSocketProtocol() {
    fmt.Printf("厂商1的通信接口数据为：%s\n", cs1.socket)
}
func (cs1 *CSckImp1) CEncDesProtocol() {
    fmt.Printf("厂商1的加密接口数据为：%s\n", cs1.data)
}

func (cs2 *CSckImp2) CSocketProtocol() {
    fmt.Printf("厂商2的通信接口数据为：%s\n", cs2.socket)
}
func (cs2 *CSckImp2) CEncDesProtocol() {
    fmt.Printf("厂商2的加密接口数据为：%s 数值为：%d\n", cs2.data,cs2.value)
}

//多态实现
func framework(i inter) {
    i.CSocketProtocol()
    i.CEncDesProtocol()
}

func main() {
    cs1 := CSckImp1{"厂商1的加密数据", "厂商1的通信数据"}
    framework(&cs1)

    cs2 := CSckImp2{"厂商2的加密数据", "厂商2的通信数据",123}
    framework(&cs2)
}

06 接口的继承和转换

package main

import "fmt"

type Humaner interface {
    //子集
    sayhi()
}

type Personer interface {
    //超集
    //继承与humaner
    Humaner

    sing(string)
}

type Student struct {
    name string
    sex  string
    age  int
}

func (s *Student) sayhi() {
    fmt.Printf("大家好，我是%s，我是%s生，我的年龄是%d\n",
        s.name, s.sex, s.age)
}

func (s *Student) sing(name string) {
    fmt.Println("我为大家唱首歌", name)
}
func main0601() {

    //接口类型变量定义
    var h Humaner

    var stu Student = Student{"王飞", "男", 35}
    h = &stu
    h.sayhi()

    //接口类型变量定义
    var p Personer
    p = &stu

    //从humaner继承来的
    p.sayhi()
    p.sing("传奇")
}
func main0602() {

    //接口类型变量定义
    var h Humaner  //子集
    var p Personer //超集
    var stu Student = Student{"王飞", "男", 35}

    h = &stu
    //将一个接口赋值给另外一个接口
    //超集中包含所有子集的方法
    h = p //ok
    h.sayhi()

    //子集不包含超集
    //可以将超集赋值给子集  不能将子集赋值给超集
    //p = h //err

    //p.sayhi()
    //p.sing("红豆")

}

07 空接口定义和使用

package main

import "fmt"

func main0701() {

    var i interface{}

    //接口类型可以接收任意类型数据

    //fmt.Printf("%T\n", i)
    //i = 10
    //fmt.Printf("%T\n", i)
    //fmt.Println(i)
    //i = 3.14
    //fmt.Printf("%T\n", i)
    //fmt.Println(i)
    //i = "传智播客"
    //fmt.Printf("%T\n", i)
    //fmt.Println(i)

    i = 10

    //接口类型 不能直接进行转换需要使用类型断言
    //var a int =20
    //var a interface{}
    //a = 20

    fmt.Println(i)
}

func test() {
    fmt.Println("test hello world")
}
func main0702() {
    //空接口类型的切片
    var i []interface{}

    //fmt.Printf("%T\n",i)
    i = append(i, 10, 3.14, "传智播客", test)

    for idx := 0; idx < len(i); idx++ {
        fmt.Println(i[idx])
    }
}

08 类型断言

package main

import "fmt"

func main0801() {
    var i interface{}
    i = 10.234
    //value,ok:=map[key]
    //值,值的判断:=接口变量.(数据类型)
    value, ok := i.(int)
    if ok {
        fmt.Println("整型数据：", value+10)
    } else {
        fmt.Println("错误")
    }

}
func demo() {
    fmt.Println("demo hello world")
}
func main() {
    var i []interface{}

    i = append(i, 10, 3.14, "传智播客", demo,123,test)

    for _, v := range i {
        //fmt.Println(idx,v)

        if data, ok := v.(int); ok {
            fmt.Println("整型数据：", data)
        } else if data, ok := v.(float64); ok {
            fmt.Println("浮点型数据：", data)
        } else if data, ok := v.(string); ok {
            fmt.Println("字符串数据：", data)
        } else if data, ok := v.(func()); ok {
            //函数调用
            data()
        }
    }

}