GO orientada a objetos (ser um especialista em CRUD) três: implementação orientada a objetos caso

Código:

package domain

// 价格计算器接口
type ItemPriceCalculator interface {
   Price() int
}

type Items []*Item

// 基类商品
type Item struct {
   ID       int
   Category int
   Title    string
   Stock    int

   PriceMarket int
}

func (dom *Item) OfInstance() interface{} {
   switch dom.Category {
   case ItemCategoryRebate:
      return dom.OfInstanceRebate()
   case ItemCategoryDiscount:
      return dom.OfInstanceDiscount()
   }

   return nil
}

// 折扣商品
type ItemDiscount struct {
   *Item
}

// 实现价格计算器接口 封装变化
func (dom *ItemDiscount) Price() int {
   return dom.PriceMarket / 2
}

// 返利商品
type ItemRebate struct {
   *Item
}

// 实现价格计算器接口 封装变化
func (dom *ItemRebate) Price() int {
   return dom.PriceMarket
}

response模型： 
package response

type Item struct {
   ID          int    `json:"id"`
   Category    int    `json:"category"`
   Title       string `json:"title"`
   Stock       int    `json:"stock"`
   PriceMarket int    `json:"priceMarket"`
   Price       int    `json:"price"`
}

func (resp *Item) Mapping(dom *domain.Item) {
   resp.ID = dom.ID
   resp.Category = dom.Category
   resp.Title = dom.Title
   resp.Stock = dom.Stock
   resp.PriceMarket = dom.PriceMarket

   instance := dom.OfInstance()
   // 断言计算价格 针对接口（或抽象）编程，而不是针对细节（或实现）编程
   if priceCalculator, ok := instance.(domain.ItemPriceCalculator); ok {
      resp.Price = priceCalculator.Price()
   }
}

Análise de código: Adicionada a interface ItemPriceCalculator.O produto de desconto ItemRebate e o produto de desconto ItemDiscount implementam a interface ItemPriceCalculator através de sua própria função Price, e calculam o preço do produto através da interface de afirmação durante a conversão de dados.

Orientado a Processos x Orientado a Objetos:

	Variedade	visadas	Código intuitivo
orientado ao processo	se mais dividir a mudança	para detalhes	Intuitivo e fácil de entender
Orientado a Objeto	Alterações de Isolamento de Hierarquia de Classe	para a interface	Resumo difícil de entender

Pensando: Orientado a processos, um problema que pode ser resolvido se, de outra forma, o método orientado a objetos adiciona uma classe de interface e dois objetos, é econômico?

Em seguida, implementaremos o cálculo do valor do desconto e se o preço de mercado de front-end está oculto.

package domain

// 返利计算器接口
type ItemRebateCalculator interface {
   Rebate() *int
}

// 市场价是否显示接口
type ItemPriceMarketDisplay interface {
   PriceMarketDisplay() bool
}

// 实现返利计算器接口 封装变化
func (dom *ItemRebate) Rebate() *int {
   rebate := dom.PriceMarket * 5 / 100
   return &rebate
}

// 实现市场价显示接口 封装变化
func (dom *ItemRebate) PriceMarketDisplay() bool {
   return true
}


package response

// 断言计算返利
if rebateCalculator, ok := instance.(domain.ItemRebateCalculator); ok {
   resp.Rebate = rebateCalculator.Rebate()
}

// 断言市场价是否显示
if rebateCalculator, ok := instance.(domain.ItemPriceMarketDisplay); ok {
   resp.PriceMarketHidden = rebateCalculator.PriceMarketDisplay()
}

Link de origem