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

简单工厂模式：。

　　简单的，只有一个工厂类，通过向工厂对象种传参来使工厂判断创建哪个类的对象，
　　通常通过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()
}