创建型设计模式——工厂模式

Posted 2022-06-23 mcmx

简单工厂模式：。

　　简单的，只有一个工厂类，通过向工厂对象种传参来使工厂判断创建哪个类的对象，
　　通常通过if、switch语句来实现，由很大的缺点，如果我们再加入要创建的新的类
　　就必须要更改工厂的源代码才可以使得工厂支持创建这个新的类的对象。
　　shi‘yong
package main
   import "fmt"

   type Product interface 
      print()
      set(num int)
   


   type Product1 struct 
      num int
   
   func (it *Product1)print()
      fmt.Println(it.num)
   
   func (it *Product1)set(num int)
      it.num = num
      fmt.Println(it.num)
   


   type Product2 struct
      num int
   
   func (it *Product2)print()
      fmt.Println(it.num)
   
   func (it *Product2)set(num int)
      it.num = num
      fmt.Println(it.num)
   



   type Factory struct 

   
   func (it *Factory)createFactory(str string) (product Product)
      switch str 
      case "Product1":
         product = new(Product1)
      case "Product2":
         product = new(Product2)
      default:

      
   return
   



   func main()
      factory := new(Factory)
      p1 := factory.createFactory("Product1")
      p2 := factory.createFactory("Product2")
      p1.set(1)
      p2.set(2)
      p1.print()
      p2.print()

   

工厂方法模式：

　　　首先说明，我们所有的要实现通过此工厂模式来创建兑现的类。都需要有一个对应的工厂类。呈现一一对应关系。且所有的类对应的工厂类都实现了
一个抽象的工厂类，也就是一个工厂模型，其它的工厂都是这个工厂的拷贝，在这个工厂的基础上加工加工，（多态）
比如说我有一个Product1和Product2都要在这个工厂模式中创建对象。有一个接口Factory,两个类对应的工厂类实现了它，Product1Factory
和Product2Factory，通过这两个工厂中的方法（自己写的）来返回一个实例对象。

    package main

   import "fmt"

   type Product interface 
      print()
      set(num int)
   


   type Product1 struct 
      num int
   
   func (it *Product1)print()
      fmt.Println(it.num)
   
   func (it *Product1)set(num int)
      it.num = num
      fmt.Println(it.num)
   


   type Product2 struct
      num int
   
   func (it *Product2)print()
      fmt.Println(it.num)
   
   func (it *Product2)set(num int)
      it.num = num
      fmt.Println(it.num)
   




   type factory interface 
   createProduct()



   type Product1Factory struct 
   
   func(it *Product1Factory)createFactory()(product Product)
   product = new(Product1)
   return



   type Product2Factory struct 
   
   func(it *Product2Factory)createFactory()(product Product)
      product = new(Product2)
      return
   

   func main()
   p1 := (new(Product1Factory).createFactory())
   p2 := (new(Product2Factory).createFactory())
   p1.set(1)
   p2.set(2)
   p1.print()
   p2.print()

   

抽象工厂模式：

　　怎么说呢，这个工厂模式，实际上是为了在一个工厂内创建多个类型的实例，比如说我们有A，A1，A2
B，B1，B2 .A,B是两个厂家，但是A1，B1是同一类商品。我们要仅仅创建一个厂家的商品。这时候就需要将不同类型的商品的创建方法放在同一个工厂中
打个最实在的比喻，小米的工厂生产小米的手机和电脑，华为的也是。他们要分开生产自个儿的，对吧。就是这，重点是将一种产品的多个不同实例分开创建

package main

import (
   "fmt"
)


type product1 interface 
   print()
   set (num int)


type product1A struct 
   num int

func(it *product1A)print()
   fmt.Println(it.num)

func(it *product1A)set(num int)
   it.num = num


type product1B struct 
   num int

func(it *product1B)print()
   fmt.Println(it.num)

func(it *product1B)set(num int)
   it.num = num




type product2 interface 
   print()
   set(num int)


type product2A struct 
   num int

func(it *product2A)print()
   fmt.Println(it.num)

func(it *product2A)set(num int)
   it.num = num
   fmt.Println(it.num)


type product2B struct 
   num int

func(it *product2B)print()
   fmt.Println(it.num)

func(it *product2B)set(num int)
   it.num = num
   fmt.Println(it.num)




type factory interface 
   createProduct1() product1
   createPRoduct2() product2


type AFactory struct 

func(it *AFactory)createProduct1() product1
   return new(product1A)

func(it *AFactory)createProduct2()product2
   return new(product2A)


type BFactory struct 
func(it *BFactory)createProduct1() product1
   return new(product1B)

func(it *BFactory)createProduct2() product2
   return  new(product2B)


func main()
   AP1 := new(AFactory).createProduct1()
   AP2 := new(AFactory).createProduct2()
   BP1 := new(BFactory).createProduct1()
   BP2 := new(BFactory).createProduct2()
   AP1.set(1)
   AP2.set(2)
   BP1.set(3)
   BP2.set(4)
   AP1.print()
   AP2.print()
   BP1.print()
   BP2.print()