Mesélj a Factory mintáról.

Gyár — ez egy létrehozó tervezési minta, amely közös interfészt biztosít az objektumok létrehozásához a szuperosztályban, míg az alosztályok módosíthatják a létrehozott objektumok típusát.

• Egyszerű gyár (Simple Factory): Nem tiszta minta, inkább egy idiom. Egy osztály metódusa, amely az bemeneti paraméterek alapján hoz létre objektumokat.

  package main
  
  import "fmt"
  
  type Product interface {
  	Use()
  }
  
  type ConcreteProductA struct{}
  
  func (p *ConcreteProductA) Use() {
  	fmt.Println("Concrete Product A használata")
  }
  
  type ConcreteProductB struct{}
  
  func (p *ConcreteProductB) Use() {
  	fmt.Println("Concrete Product B használata")
  }
  
  type SimpleFactory struct{}
  
  func (f *SimpleFactory) CreateProduct(t string) Product {
  	switch t {
  	case "A":
  		return &ConcreteProductA{}
  	case "B":
  		return &ConcreteProductB{}
  	default:
  		return nil
  	}
  }
  
  func main() {
  	factory := SimpleFactory{}
  	productA := factory.CreateProduct("A")
  	productA.Use()
  
  	productB := factory.CreateProduct("B")
  	productB.Use()
  }
  

• Gyármetódus (Factory Method): Interfész az objektum létrehozásához, de lehetővé teszi az alosztályoknak, hogy eldöntsék, melyik osztályt példányosítják.

  package main
  
  import "fmt"
  
  // Termék interfész
  type Product interface {
  	Operation() string
  }
  
  // Konkrét termék A
  type ConcreteProduct1 struct{}
  
  func (p *ConcreteProduct1) Operation() string {
  	return "A ConcreteProduct eredménye"
  }
  
  // Konkrét termék B
  type ConcreteProduct2 struct{}
  
  func (p *ConcreteProduct2) Operation() string {
  	return "B ConcreteProduct eredménye"
  }
  
  // Létrehozó interfész
  type Creator interface {
  	FactoryMethod() Product
  	SomeOperation() string
  }
  
  // Alap létrehozó struktúra
  type BaseCreator struct{}
  
  func (bc *BaseCreator) SomeOperation() string {
  	// A gyártási módszer meghívása a termék objektumának megszerzéséhez
  	product := bc.FactoryMethod()
  	// A termék használata
  	result := "A: Ugyanaz a kód, amely csak a " + product.Operation() + "-val működött"
  	return result
  }
  
  // Konkrét létrehozó A
  type ConcreteCreator1 struct {
  	BaseCreator
  }
  
  func (cc *ConcreteCreator1) FactoryMethod() Product {
  	return &ConcreteProduct1{} // Konkrét termék A létrehozása
  }
  
  // Konkrét létrehozó B
  type ConcreteCreator2 struct {
  	BaseCreator
  }
  
  func (cc *ConcreteCreator2) FactoryMethod() Product {
  	return &ConcreteProduct2{} // Konkrét termék B létrehozása
  }
  
  func main() {
  	// Használati példa
  	creator1 := &ConcreteCreator1{}
  	fmt.Println(creator1.SomeOperation())
  
  	creator2 := &ConcreteCreator2{}
  	fmt.Println(creator2.SomeOperation())
  }
  

• Absztrakt gyár (Abstract Factory): Interfészt biztosít kapcsolódó vagy függő objektum családok létrehozásához anélkül, hogy azok konkrét osztályait megadná.

  package main
  
  import "fmt"
  
  // Termék A interfész
  type AbstractProductA interface {
  	UseProductA() string
  }
  
  // Konkrét termék A1
  type ConcreteProductA1 struct{}
  
  func (*ConcreteProductA1) UseProductA() string {
  	return "A termék A1 eredménye."
  }
  
  // Konkrét termék A2
  type ConcreteProductA2 struct{}
  
  func (*ConcreteProductA2) UseProductA() string {
  	return "A termék A2 eredménye."
  }
  
  // Termék B interfész
  type AbstractProductB interface {
  	UseProductB() string
  	AnotherFunctionB(collaborator AbstractProductA) string // Együttműködés a termék A-val
  }
  
  // Konkrét termék B1
  type ConcreteProductB1 struct{}
  
  func (*ConcreteProductB1) UseProductB() string {
  	return "B termék B1 eredménye."
  }
  
  func (*ConcreteProductB1) AnotherFunctionB(collaborator AbstractProductA) string {
  	result := collaborator.UseProductA()
  	return fmt.Sprintf("A B1 együttműködés eredménye (%s)", result)
  }
  
  // Konkrét termék B2
  type ConcreteProductB2 struct{}
  
  func (*ConcreteProductB2) UseProductB() string {
  	return "B termék B2 eredménye."
  }
  
  func (*ConcreteProductB2) AnotherFunctionB(collaborator AbstractProductA) string {
  	result := collaborator.UseProductA()
  	return fmt.Sprintf("A B2 együttműködés eredménye (%s)", result)
  }
  
  // Absztrakt gyár interfész
  type AbstractFactory interface {
  	CreateProductA() AbstractProductA
  	CreateProductB() AbstractProductB
  }
  
  // Konkrét gyár 1
  type ConcreteFactory1 struct{}
  
  func (*ConcreteFactory1) CreateProductA() AbstractProductA {
  	return &ConcreteProductA1{}
  }
  
  func (*ConcreteFactory1) CreateProductB() AbstractProductB {
  	return &ConcreteProductB1{}
  }
  
  // Konkrét gyár 2
  type ConcreteFactory2 struct{}
  
  func (*ConcreteFactory2) CreateProductA() AbstractProductA {
  	return &ConcreteProductA2{}
  }
  
  func (*ConcreteFactory2) CreateProductB() AbstractProductB {
  	return &ConcreteProductB2{}
  }
  
  // Ügyfélkód, amely a gyárat használja
  func ClientCode(factory AbstractFactory) {
  	productA := factory.CreateProductA()
  	productB := factory.CreateProductB()
  
  	fmt.Println(productB.UseProductB())
  	fmt.Println(productB.AnotherFunctionB(productA))
  }
  
  func main() {
  	fmt.Println("Ügyfél: Első gyártó típusával tesztelés:")
  	ClientCode(&ConcreteFactory1{})
  
  	fmt.Println("Ügyfél: Ugyanaz ügyfélkód második gyártó típusával tesztelés:")
  	ClientCode(&ConcreteFactory2{})
  }
  

A fő különbség a Gyármetódus és az Absztrakt gyár között: A Gyármetódus egyedi termékeket hoz létre, míg az Absztrakt gyár termékcsaládokat.

Név	Leírás	Mikor használjuk
Egyszerű gyár	Egy osztály metódusa különböző típusú objektumok létrehozására.	Egyszerű objektumok létrehozására, amikor nincs szükség hierarchiára.
Gyármetódus	Interfész az objektum létrehozásához, amely lehetővé teszi az alosztályoknak, hogy eldöntsék, melyik osztályt példányosítják.	Amikor az osztály nem tudja előre, milyen típusú objektumokat kell létrehoznia.
Absztrakt gyár	Interfészt biztosít kapcsolódó vagy függő objektum családok létrehozásához.	Amikor a rendszernek függetlennek kell lennie a termékek létrehozásának módjától és reprezentációjától.

A Gyár minta segít a laza kapcsolódásban és megkönnyíti az új típusú termékek hozzáadását anélkül, hogy módosítani kellene a klienskódot.