数字营销 h5 网站开发,新手怎么引流推广,网站栏目设计,代理备案网站系列文章目录
第一章 设计模式案例 (一) 第一章 设计模式案例 #xff08;二) 文章目录 系列文章目录前言一、责任链模式case 包 二、策略模式case 包 三、工厂模式case 包 前言
上一篇文章介绍了常用的几种设计模式和常用场景#xff0c;便于对设计模式加深理解#xff0…系列文章目录
第一章 设计模式案例 (一) 第一章 设计模式案例 二) 文章目录 系列文章目录前言一、责任链模式case 包 二、策略模式case 包 三、工厂模式case 包 前言
上一篇文章介绍了常用的几种设计模式和常用场景便于对设计模式加深理解此文章主要讲解设计模式的案例。 一、责任链模式
case 包 代码如下示例 package _case
import fmt
func DutyCase() {pm : ProjectManager{}dm : DepartmentManager{}gm : GeneralManager{}pm.SetNext(dm).SetNext(gm)pm.Handle(张三, 300)pm.Handle(李四, 800)pm.Handle(王五, 1800)
}
type Handler interface {SetNext(h Handler) HandlerHandle(user string, amount int64)
}
// 项目经理
type ProjectManager struct {next Handler
}
func (pm *ProjectManager) Handle(user string, amount int64) {if amount 500 {fmt.Printf(%s 申请聚餐费用 %d 元项目经理审批通过\n, user, amount)return}// 项目经理没有权限交给下一个人处理pm.next.Handle(user, amount)
}
func (pm *ProjectManager) SetNext(h Handler) Handler {pm.next hreturn h
}
// 部门经理
type DepartmentManager struct {next Handler
}
func (dm *DepartmentManager) Handle(user string, amount int64) {if amount 500 amount 1000 {fmt.Printf(%s 申请聚餐费用 %d 元部门经理审批通过\n, user, amount)return} else if amount 1000 {fmt.Printf(%s 申请聚餐费用 %d 元部门经理审批通过总经理加签\n, user, amount)dm.next.Handle(user, amount)} else {dm.next.Handle(user, amount)}
}
func (dm *DepartmentManager) SetNext(h Handler) Handler {dm.next hreturn h
}
// 总经理
type GeneralManager struct {next Handler
}
func (gm *GeneralManager) Handle(user string, amount int64) {if amount 1000 {fmt.Printf(%s 申请聚餐费用 %d 元总经理审批通过\n, user, amount)return}gm.next.Handle(user, amount)
}
func (gm *GeneralManager) SetNext(h Handler) Handler {gm.next hreturn h
}
代码如下示例main
package main
import _case design-pattern/duty/case
func main() {_case.DutyCase()
} 二、策略模式
case 包 代码如下示例 package _caseimport fmtfunc StrategyCase() {arr : []int{1, 3, 8, 2, 4, 5}arr1 : []int{5, 2, 4, 6, 9, 8}ctx : Context{}//设置排序策略- 冒泡算法ctx.SetStrategy(bubble{})ctx.ExecuteStrategy(arr)fmt.Println(arr)//设置排序策略-选择策略ctx.SetStrategy(selection{})ctx.ExecuteStrategy(arr1)fmt.Println(arr1)
}// 排序策略定义
type SortStrategy interface {Sort(arr []int)
}// 冒泡排序
type bubble struct{}func (*bubble) Sort(arr []int) {fmt.Println(冒泡算法)n : len(arr)for i : 0; i n-1; i {flag : falsefor j : 0; j n-1-i; j {if arr[j] arr[j1] {arr[j], arr[j1] arr[j1], arr[j]flag true}}if !flag {break}}
}// 选择排序
type selection struct{}func (*selection) Sort(arr []int) {fmt.Println(选择排序)size : len(arr)for i : 0; i size-1; i {minIndex : ifor j : i 1; j size; j {if arr[j] arr[minIndex] {minIndex j}}if minIndex ! i {arr[i], arr[minIndex] arr[minIndex], arr[i]}}
}type Context struct {stratety SortStrategy
}func (ctx *Context) SetStrategy(s SortStrategy) {ctx.stratety s
}func (ctx *Context) ExecuteStrategy(arr []int) {ctx.stratety.Sort(arr)
}代码如下示例main
package mainimport _case design-pattern/trategy/casefunc main() {_case.StrategyCase()
}
}三、工厂模式
case 包 代码如下示例简单工厂 package _case
type Product interface {GetName() string
}
type ProductA struct {name string
}
func (a *ProductA) GetName() string {return a.name
}
type ProductB struct {name string
}
func (b *ProductB) GetName() string {return b.name
}
type ProductC struct {name string
}
func (c *ProductC) GetName() string {return c.name
} package _case
import (fmt
)
type SimpleFactory struct {
}
func (f *SimpleFactory) CreateProduct(productType string) Product {switch productType {case A:return ProductA{name: product A,}case B:return ProductB{name: product B,}case C:return ProductC{name: product C,}}return nil
}
func SimpleFactoryCase() {factory : SimpleFactory{}var product Productproduct factory.CreateProduct(A)fmt.Println(product.GetName())product factory.CreateProduct(B)fmt.Println(product.GetName())product factory.CreateProduct(C)if product ! nil {fmt.Println(product.GetName())}
}代码如下示例简单工厂 package _case
type Product interface {GetName() string
}
type ProductA struct {name string
}
func (a *ProductA) GetName() string {return a.name
}
type ProductB struct {name string
}
func (b *ProductB) GetName() string {return b.name
}
type ProductC struct {name string
}
func (c *ProductC) GetName() string {return c.name
}
package _case
import fmt
type Factory interface {CreateProduct() Product
}
type FactoryA struct {
}
func (f *FactoryA) CreateProduct() Product {return ProductA{name: product A,}
}
type FactoryB struct {
}
func (f *FactoryB) CreateProduct() Product {return ProductB{name: product B,}
}
type FactoryC struct {
}
func (f *FactoryC) CreateProduct() Product {return ProductC{name: product C,}
}
func FactoryMethodCase() {var factory Factoryvar product Productfactory FactoryA{}product factory.CreateProduct()fmt.Println(product.GetName())factory FactoryB{}product factory.CreateProduct()fmt.Println(product.GetName())factory FactoryC{}product factory.CreateProduct()fmt.Println(product.GetName())
}
代码如下示例main
package main
import _case design-pattern/factory/case
func main() {//_case.SimpleFactoryCase()_case.FactoryMethodCase()
}
