readme

Author: kimi0230

Facade/README.md

@@ -21,4 +21,66 @@
 外觀模式是一結構型模式,
 中介者模式是一行為性模式
 
-![UML](https://github.com/kimi0230/DesignPatternGolang/blob/master/UML/Facade.png?raw=true)
+![UML](https://github.com/kimi0230/DesignPatternGolang/blob/master/UML/Facade.png?raw=true)
+
+### Example
+https://github.com/kimi0230/DesignPatternGolang/tree/master/Facade 
+
+```go
+package facade
+
+import "fmt"
+
+// 外觀類別, 她需要了解所有的子系統的方法或屬性, 並進行組合, 以備外界調用
+type Facade struct {
+	One   SubSystemOne
+	Two   SubSystemTwo
+	Three SubSystemThree
+	Four  SubSystemFour
+}
+
+func NewFacade() *Facade {
+	return &Facade{SubSystemOne{}, SubSystemTwo{}, SubSystemThree{}, SubSystemFour{}}
+}
+
+func (f *Facade) MethodA() {
+	fmt.Println("方法組 A")
+	f.One.MethodOne()
+	f.Three.MethodThree()
+}
+
+func (f *Facade) MethodB() {
+	fmt.Println("方法組 B")
+	f.Two.MethodTwo()
+	f.Four.MethodFour()
+}
+
+type SubSystemOne struct {
+}
+
+func (s *SubSystemOne) MethodOne() {
+	fmt.Println("子系統方法一")
+}
+
+type SubSystemTwo struct {
+}
+
+func (s *SubSystemTwo) MethodTwo() {
+	fmt.Println("子系統方法二")
+}
+
+type SubSystemThree struct {
+}
+
+func (s *SubSystemThree) MethodThree() {
+	fmt.Println("子系統方法三")
+}
+
+type SubSystemFour struct {
+}
+
+func (s *SubSystemFour) MethodFour() {
+	fmt.Println("子系統方法四")
+}
+
+```

FactoryMethod/README.md

@@ -10,4 +10,129 @@
 
 > Ex: 計算機
 
-![UML](https://github.com/kimi0230/DesignPatternGolang/blob/master/UML/Factory.png?raw=true)
+![UML](https://github.com/kimi0230/DesignPatternGolang/blob/master/UML/Factory.png?raw=true)
+
+### Example
+https://github.com/kimi0230/DesignPatternGolang/tree/master/FactoryMethod 
+
+```go
+/*
+Factory Method 工廠方法模式： 由次類別決定要建立的具象類別為何者
+	定義一個用於創建對象的接口，讓子類決定實例化哪一個類
+	是一種管理物件創建的模式，隨著輸入的參數不同，簡單工廠會回傳不同的物件
+	使用者取得物件的時候只要傳入正確的參數，不需要去理解這個物件
+	是一個使一個類的實例化延遲到其子類
+此範例為 簡單工廠
+*/
+package factorymethod
+
+type OperationFunc interface {
+	SetNumA(float32)
+	SetNumB(float32)
+	GetNumA() float32
+	GetNumB() float32
+	GetResult() (float32, bool)
+}
+
+type Operation struct {
+	numberA float32
+	numberB float32
+}
+
+func (o *Operation) SetNumA(num float32) {
+	if o == nil {
+		return
+	}
+	o.numberA = num
+}
+
+func (o *Operation) SetNumB(num float32) {
+	if o == nil {
+		return
+	}
+	o.numberB = num
+}
+func (o *Operation) GetNumA() float32 {
+	if o == nil {
+		return 0
+	}
+	return o.numberA
+}
+func (o *Operation) GetNumB() float32 {
+	if o == nil {
+		return 0
+	}
+	return o.numberB
+}
+
+// 加法
+type OperationAdd struct {
+	Operation
+}
+
+func (o *OperationAdd) GetResult() (float32, bool) {
+	if o == nil {
+		return 0, false
+	}
+	return o.numberA + o.numberB, true
+}
+
+// 減
+type OperationSub struct {
+	Operation
+}
+
+func (o *OperationSub) GetResult() (float32, bool) {
+	if o == nil {
+		return 0, false
+	}
+	return o.numberA - o.numberB, true
+}
+
+// 乘
+type OperationMul struct {
+	Operation
+}
+
+func (o *OperationMul) GetResult() (float32, bool) {
+	if o == nil {
+		return 0, false
+	}
+	return o.numberA * o.numberB, true
+}
+
+// 除
+type OperationDiv struct {
+	Operation
+}
+
+func (o *OperationDiv) GetResult() (float32, bool) {
+	if o == nil {
+		return 0, false
+	}
+	if o.numberB == 0 {
+		return 0, false
+	}
+	return o.numberA / o.numberB, true
+}
+
+// 建立工廠
+type OperationFactory struct {
+	oper string
+}
+
+func (of *OperationFactory) createoperation(op string) OperationFunc {
+	switch op {
+	case "+":
+		return &OperationAdd{}
+	case "-":
+		return &OperationSub{}
+	case "*":
+		return &OperationMul{}
+	case "/":
+		return &OperationDiv{}
+	}
+	return nil
+}
+
+```

FactoryMethod/SimplevsFactory/README.md

@@ -10,4 +10,84 @@
 工廠方法把簡單工廠的內部邏輯判斷移到了用戶端程式碼來進行
 如果要加功能, 本來是改工廠類型, 現在是修改用戶端
 是簡單工廠模式的進一步抽象.
-缺點是每加一個產品就需要加一個產品工廠的類別, 增加額外的開發量
+缺點是每加一個產品就需要加一個產品工廠的類別, 增加額外的開發量
+
+### Example
+https://github.com/kimi0230/DesignPatternGolang/tree/master/FactoryMethod/SimplevsFactory
+
+```go
+/*
+簡單工廠 vs. 工廠方法
+簡單工廠
+	最大優點在於工廠類別中包含了必要的邏輯判斷, 根據用戶端的選擇條件動態實體化相關的類別
+	對用戶端來說, 去除了與具體產品的依賴
+	但是違背了 開放封閉原則
+工廠模式
+	用戶端需決定實體化哪一個工廠來實現運算類別, 選擇判斷的問題還是存在
+	工廠方法把簡單工廠的內部邏輯判斷移到了用戶端程式碼來進行
+	如果要加功能, 本來是改工廠類型, 現在是修改用戶端
+	是簡單工廠模式的進一步抽象.
+	缺點是每加一個產品就需要加一個產品工廠的類別, 增加額外的開發量
+*/
+package simplevsfactory
+
+import "fmt"
+
+type NigtingaleInterface interface {
+	Sweep()
+	Wash()
+	BuyRice()
+}
+type Nigtingale struct {
+}
+
+func (n *Nigtingale) Sweep() {
+	fmt.Println("掃地")
+}
+func (n *Nigtingale) Wash() {
+	fmt.Println("洗衣")
+}
+func (n *Nigtingale) BuyRice() {
+	fmt.Println("買米")
+}
+
+type Undergraduate struct {
+	Nigtingale
+}
+
+type Volunteer struct {
+	Nigtingale
+}
+
+type SimpleFactory struct {
+}
+
+func (s *SimpleFactory) CreateNightingale(factoryType string) NigtingaleInterface {
+	var result NigtingaleInterface
+	switch factoryType {
+	case "學男丁格爾的大學生":
+		result = new(Undergraduate)
+		return result
+	case "社區義工":
+		result = new(Volunteer)
+		return result
+	}
+	return nil
+}
+
+type IFactory interface {
+	CreateNightingale()
+}
+
+type UndergraduateFactory struct{}
+
+func (u *UndergraduateFactory) CreateNightingale() NigtingaleInterface {
+	return new(Undergraduate)
+}
+
+type VolunteerFactory struct{}
+
+func (u *VolunteerFactory) CreateNightingale() NigtingaleInterface {
+	return new(Volunteer)
+}
+```

Flyweight/README.md

@@ -7,4 +7,62 @@
 像是圍棋棋子物件可以減少到只有兩個實體.
 開發一個可供多人註冊的部落格網站
 
-![UML](https://github.com/kimi0230/DesignPatternGolang/blob/master/UML/Flyweight.png?raw=true)
+![UML](https://github.com/kimi0230/DesignPatternGolang/blob/master/UML/Flyweight.png?raw=true)
+
+### Example
+https://github.com/kimi0230/DesignPatternGolang/tree/master/Flyweight 
+
+```go
+package flyweight
+
+import "fmt"
+
+type Flyweight interface {
+	Operation(int)
+}
+
+type ConcreteFlyweight struct {
+	name string
+}
+
+func (c *ConcreteFlyweight) Operation(extrinsicState int) {
+	if c == nil {
+		return
+	}
+	fmt.Println("具體 Flyweight", extrinsicState)
+}
+
+type UnsharedConcreteFlyweight struct {
+	name string
+}
+
+func (c *UnsharedConcreteFlyweight) Operation(extrinsicState int) {
+	if c == nil {
+		return
+	}
+	fmt.Println("不共用的具體 Flyweight", extrinsicState)
+}
+
+type FlyweightFactory struct {
+	flyweights map[string]Flyweight
+}
+
+func NewFlyweightFactory() *FlyweightFactory {
+	fwfactory := FlyweightFactory{make(map[string]Flyweight)}
+	fwfactory.flyweights["X"] = &ConcreteFlyweight{"X"}
+	fwfactory.flyweights["Y"] = &ConcreteFlyweight{"Y"}
+	fwfactory.flyweights["Z"] = &ConcreteFlyweight{"Z"}
+	return &fwfactory
+}
+
+func (f *FlyweightFactory) Flyweight(name string) Flyweight {
+	if f == nil {
+		return nil
+	}
+	if _, ok := f.flyweights[name]; !ok {
+		f.flyweights[name] = &ConcreteFlyweight{name}
+	}
+	return f.flyweights[name]
+}
+
+```