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

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

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

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

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

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

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

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

//使用接口
    @H_674_101@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 @H_674_101@struct {
     num1 @H_674_101@int
     num2 @H_674_101@int
 }

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

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

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

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

 //定义接口,即封装

 type Opter @H_674_101@interface {
     Opt() @H_674_101@int
 }

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

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

 }

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

//??????????????????????????????????????????


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