week03 单例作业以及组合模式

用户头像
李锦
关注
发布于: 2020 年 06 月 23 日



单例模式,就是用来保证一个对象只能创建一个实例,当然,它还提供对实例的全局访问方法。单例模式实现方式如下图:





单例模式显示只由单个类组成。为确保单例的唯一性,所有单例构造器都要被声明为私有(private),通过声明静态(static)方法实现全局访问获得该单例实例。






代码建模

责任链模式主要类主要包含如下特性:

  • 成员属性

  • ChildComponents: 子组件列表 -> 稳定不变的

  • 成员方法

  • Do: 执行组件&子组件 -> 变化的



伪代码实现如下:




一个父类(抽象类):
- 成员属性
+ `ChildComponents`: 子组件列表
- 成员方法
+ `Do`: 抽象方法
组件一,winfrom 窗口(继承父类、看成一个大的组件):
- 成员方法
+ `Do`: 执行当前组件的逻辑,执行子组件的逻辑
组件二,picture(继承父类):
- 成员方法
+ `Do`: 执行当前组件的逻辑,执行子组件的逻辑
组件三,button(继承父类):
- 成员方法
+ `Do`: 执行当前组件的逻辑,执行子组件的逻辑
组件四,button(继承父类):
- 成员方法
+ `Do`: 执行当前组件的逻辑,执行子组件的逻辑
组件五,frame(继承父类):
- 成员方法
+ `Do`: 执行当前组件的逻辑,执行子组件的逻辑
组件六,lable(继承父类):
- 成员方法
+ `Do`: 执行当前组件的逻辑,执行子组件的逻辑
组件七,textBox(继承父类):
- 成员方法
+ `Do`: 执行当前组件的逻辑,执行子组件的逻辑
组件八,Lable(继承父类):
- 成员方法
+ `Do`: 执行当前组件的逻辑,执行子组件的逻辑
组件九,PasswordBox(继承父类):
- 成员方法
+ `Do`: 执行当前组件的逻辑,执行子组件的逻辑
组件十,CheckBox(继承父类):
- 成员方法
+ `Do`: 执行当前组件的逻辑,执行子组件的逻辑
组件十一,TextBox(继承父类):
- 成员方法
+ `Do`: 执行当前组件的逻辑,执行子组件的逻辑
组件十二,Linkable(继承父类,未来扩展的组件):
- 成员方法
+ `Do`: 执行当前组件的逻辑,执行子组件的逻辑






一个接口(interface):
+ 抽象方法`Do`: 执行组件&子组件
一个基础结构体`BaseComponent`:
- 成员属性
+ `ChildComponents`: 子组件列表
- 成员方法
+ 实体方法`ChildsDo`: 执行子组件
组件一,winfrom:
- 合成复用基础结构体`BaseComponent`
- 成员方法
+ `Do`: 执行当前组件的逻辑,执行子组件的逻辑
组件二,picture:
- 合成复用基础结构体`BaseComponent`
- 成员方法
+ `Do`: 执行当前组件的逻辑,执行子组件的逻辑
组件三,button:
- 合成复用基础结构体`BaseComponent`
- 成员方法
+ `Do`: 执行当前组件的逻辑,执行子组件的逻辑
...略
组件十一,Linkable:
- 合成复用基础结构体`BaseComponent`
- 成员方法
+ `Do`: 执行当前组件的逻辑,执行子



demo 代码:




package main
import (
"fmt"
"reflect"
"runtime"
)
//------------------------------------------------------------
//李锦的测试代码
//组合模式打印输出窗口
//------------------------------------------------------------
// Context 上下文
type Context struct{}
// Component 组件接口
type Component interface {
// 执行组件&子组件
Do(ctx *Context) error
}
// BaseComponent 基础组件
type BaseComponent struct {
// 子组件列表
ChildComponents []Component
}
// Do 执行组件&子组件
func (bc *BaseComponent) Do(ctx *Context) (err error) {
// do nothing
return
}
// ChildsDo 执行子组件
func (bc *BaseComponent) ChildsDo(ctx *Context) (err error) {
// 执行子组件
for _, childComponent := range bc.ChildComponents {
if err = childComponent.Do(ctx); err != nil {
return err
}
}
return
}
// WinFromComponent WinForm页面组件
type WinFromComponent struct {
// 合成复用基础组件
BaseComponent
}
// Do 执行组件&子组件
func (bc *WinFromComponent) Do(ctx *Context) (err error) {
// 当前组件的业务逻辑写这
fmt.Println(runFuncName(), "WinForm...")
// 执行子组件
bc.ChildsDo(ctx)
// 当前组件的业务逻辑写这
return
}
// PicComponent LOGO图片组件
type PicComponent struct {
// 合成复用基础组件
BaseComponent
}
// Do 执行组件&子组件
func (bc *PicComponent) Do(ctx *Context) (err error) {
// 当前组件的业务逻辑写这
fmt.Println(runFuncName(), "图片组件...")
// 执行子组件
bc.ChildsDo(ctx)
// 当前组件的业务逻辑写这
return
}
// Button1Component 登录组件
type Button1Component struct {
// 合成复用基础组件
BaseComponent
}
// Do 执行组件&子组件
func (bc *Button1Component) Do(ctx *Context) (err error) {
// 当前组件的业务逻辑写这
fmt.Println(runFuncName(), "登录按钮组件...")
// 执行子组件
bc.ChildsDo(ctx)
// 当前组件的业务逻辑写这
return
}
// ButtonRComponent 注册按钮组件
type ButtonRComponent struct {
// 合成复用基础组件
BaseComponent
}
// Do 执行组件&子组件
func (bc *ButtonRComponent) Do(ctx *Context) (err error) {
// 当前组件的业务逻辑写这
fmt.Println(runFuncName(), "注册按钮组件...")
// 执行子组件
bc.ChildsDo(ctx)
// 当前组件的业务逻辑写这
return
}
// FrameComponent Frame1组件
type FrameComponent struct {
// 合成复用基础组件
BaseComponent
}
// Do 执行组件&子组件
func (bc *FrameComponent) Do(ctx *Context) (err error) {
// 当前组件的业务逻辑写这
fmt.Println(runFuncName(), "Frame1组件...")
// 执行子组件
bc.ChildsDo(ctx)
// 当前组件的业务逻辑写这
return
}
// LableComponent 用户名组件
type LableComponent struct {
// 合成复用基础组件
BaseComponent
}
// Do 执行组件&子组件
func (bc *LableComponent) Do(ctx *Context) (err error) {
// 当前组件的业务逻辑写这
fmt.Println(runFuncName(), "用户名组件...")
// 执行子组件
bc.ChildsDo(ctx)
// 当前组件的业务逻辑写这
return
}
// TextComponent 文本框组件
type TextComponent struct {
// 合成复用基础组件
BaseComponent
}
// Do 执行组件&子组件
func (bc *TextComponent) Do(ctx *Context) (err error) {
// 当前组件的业务逻辑写这
fmt.Println(runFuncName(), "文本框组件...")
// 执行子组件
bc.ChildsDo(ctx)
// 当前组件的业务逻辑写这
return
}
// LablePComponent 密码组件
type LablePComponent struct {
// 合成复用基础组件
BaseComponent
}
// Do 执行组件&子组件
func (bc *LablePComponent) Do(ctx *Context) (err error) {
// 当前组件的业务逻辑写这
fmt.Println(runFuncName(), "密码组件...")
// 执行子组件
bc.ChildsDo(ctx)
// 当前组件的业务逻辑写这
return
}
// PasswordBoxComponent 密码框组件
type PasswordBoxComponent struct {
// 合成复用基础组件
BaseComponent
}
// Do 执行组件&子组件
func (bc *PasswordBoxComponent) Do(ctx *Context) (err error) {
// 当前组件的业务逻辑写这
fmt.Println(runFuncName(), "密码框组件...")
// 执行子组件
bc.ChildsDo(ctx)
// 当前组件的业务逻辑写这
return
}
// CheckBoxComponent 复选框组件
type CheckBoxComponent struct {
// 合成复用基础组件
BaseComponent
}
// Do 执行组件&子组件
func (bc *CheckBoxComponent) Do(ctx *Context) (err error) {
// 当前组件的业务逻辑写这
fmt.Println(runFuncName(), "复选框组件...")
// 执行子组件
bc.ChildsDo(ctx)
// 当前组件的业务逻辑写这
return
}
// TextComponent 记住用户名组件
type TextComponent struct {
// 合成复用基础组件
BaseComponent
}
// Do 执行组件&子组件
func (bc *TextComponent) Do(ctx *Context) (err error) {
// 当前组件的业务逻辑写这
fmt.Println(runFuncName(), "记住用户名组件...")
// 执行子组件
bc.ChildsDo(ctx)
// 当前组件的业务逻辑写这
return
}
// LinkLableComponent 忘记密码组件
type LinkLableComponent struct {
// 合成复用基础组件
BaseComponent
}
// Do 执行组件&子组件
func (bc *LinkLableComponent) Do(ctx *Context) (err error) {
// 当前组件的业务逻辑写这
fmt.Println(runFuncName(), "忘记密码组件...")
// 执行子组件
bc.ChildsDo(ctx)
// 当前组件的业务逻辑写这
return
}
func main() {
// 初始化WinForm页面 这个大组件
WinFrom := &WinFromComponent{}
// 挂载子组件
FrameComponent := &FrameComponent{}
// 开始构建组件数据
WinFrom.Do(&Context{})
}
// 获取正在运行的函数名
func runFuncName() string {
pc := make([]uintptr, 1)
runtime.Callers(2, pc)
f := runtime.FuncForPC(pc[0])
return f.Name()



用户头像

李锦

关注

还未添加个人签名 2017.11.30 加入

还未添加个人简介

评论

发布
暂无评论
week03 单例作业以及组合模式