シンプルなファクトリパターン：
シンプルで、唯一のファクトリクラス、オブジェクトが作成されたクラスを決定するために工場出荷時のオブジェクト参照の植物種でパスを作るために、
通常であればによって、switch文、大きな欠点は、我々は、作成する新しいクラスを追加した場合
植物が、オブジェクトのこの新しいクラスの作成をサポートして作ることができる植物のソースコードを変更する必要があります。
shi'yong
パッケージメイン
インポート"FMT"
タイプのインターフェース製品{
印刷（）
SET（NUM INTは）
}
型製品1は、構造体である{
NUM INTが
}
FUNCが（製品1はIT *）プリント（）{
fmt.Println（it.num）
}
FUNC（ *製品1は、ITは、{）SET（NUMはint）である
it.num NUM =
fmt.Println（it.num）
}
Product2が構造体{されるタイプ
NUMはint
}
FUNC（IT * Product2である）プリント（）{
fmt.Println（it.num）
}
FUNC（それ* Product2）セット（NUM INT）{
it.num = NUM
fmt.Println（it.num）
}
型工場のstruct {
}
FUNC（それ*工場）createFactory（STR列）（商品製品）{
スイッチSTR {
場合"製品1"：
製品=新しい（製品1）
ケース"Product2"：
製品=新しい（Product2）
デフォルト：
}
戻り
}
FUNCメイン（）{
工場：=新しい（工場）
P1：= factory.createFactory（ "製品1"）
P2：= factory.createFactory（ "Product2"）
p1.set（1）
p2.set（2）
p1.print（）
P2。プリント（）
}
Factory Methodパターン：
私たちが達成したいすべての最初には、クラスを称えるために、このファクトリパターンによって作成されます。私たちは、対応するクラスファクトリを持っている必要があります。これは、1つの関係を示しています。そして、対応するクラスファクトリクラスの全てが実装
モデル工場で抽象ファクトリクラスを、他の工場は、処理（マルチ状態）を処理する上で、この工場に基づいて、この植物のコピーである
例えば、私が持っています製品1とProduct2は、この工場モードでオブジェクトを作成する必要があります。クラスファクトリに対応する2つのクラスがそれを達成するためのインタフェースの工場を持ち、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{
新しい（product2A）を返す
}
BFactory構造体{}入力
{FUNC（それ* BFactory）createProduct1（）製品1を
新しい（product1B）を返す
}
FUNC（それ* BFactory）createProduct2（）product2 {
新しい（product2B）を返す
}
{）主FUNCを（
AP1：=新しい（AFactory）.createProduct1（）
AP2：=新しい（AFactory）.createProduct2（）
BP1：=新しい（BFactory）.createProduct1（）
BP2：=新しい（BFactory）.createProduct2（）
AP1.set（1）
AP2.set（2）
BP1.set（3）
BP2.set（4）
AP1.print（）
AP2.print（）
BP1.print（）
BP2.print（）
}