type BaseNum struct {
     num1 int
     num2 int
} // BaseNum 即为父类型名称

type Add struct {
    BaseNum
} //加法子类, 定义加法子类的主要目的, 是为了定义对应子类的方法

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

func (a *Add)Opt()(value int) {
    return a.num1 + a.num2
}//加法的方法实现

func (s *Sub)Opt()(value int) {
    return s.num1 + s.num2
}//减法的方法实现

type Opter interface { //接口定义
    Opt()int      //封装, 归纳子类方法, 注意此处需要加上返回值, 不然没有办法输出返回值(因为方法中使用了返回值)
}

func MultiState(o *Opter)(value int) { //多态定义, 可以简单理解为以接口作为形参的函数, 方便学习
    value = o.Opt()
    return
}

func main(){
    var a Add = Add{BaseNum{2,3}}
   
 //使用Add对象方法
    value := a.Opt()

//使用接口
    var i Opter
    i = &a
    value := i.Opt()

//使用多态
    i = &a
    value := MultiState(i)
//输出测试
    fmt.Println(value)
}

package main

import "fmt"

/*
    实例: 面向对象的计算器实现

        1.定义父类
        2.定义子类,以及子类的方法 运算实现
        3.定义接口, 归纳 子类方法
        4.定义空类, 定义空类的方法,即 工厂模式, 将 运算符 与 数值 分开处理, 以运算符来分发方法, 方便调用
        5.定义一个多态, 将接口归纳, 方便调用
        6.主函数, 初始化, 调用工厂模式, 进行验证

 */

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

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

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

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

 func (s *Sub)Opt() int {
     return s.num1 - s.num2
 }

 //定义接口, 即封装

 type Opter interface {
     Opt() int
 }

 //定义多态
 func MultiState(o Opter) int{
     value:=o.Opt()
     return value
 }

 //定义空类 以产生 工厂模式 的方法
 type Factory struct {

 }

//⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️
 func (f *Factory)FacMethod(a,b int,operator string) (value int){
     var i Opter
     switch operator {
     case "+":
             var AddNum Add = Add{BaseNum{a,b}}
             i = &AddNum
     case "-":
             var SubNum Sub = Sub{BaseNum{a,b}}
             i = &SubNum
     }
     //接口实现 : value = i.Opt()
     value = MultiState(i) //多态实现
     return
 }

//⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️


func main() {
    var a Factory
    value := a.FacMethod(20,3,"-")
    fmt.Println(value)
}