Factory naqshining haqida gapir.

Fabrika — bu yaratish uchun mo'ljallangan dizayn shabloni bo'lib, u superklassda umumiy interfeysni taqdim etadi, podklasslar esa yaratilayotgan ob'ektlarning turini o'zgartirishlari mumkin.

• Oddiy fabrika (Simple Factory): Bu toza shaklda shablon emas, balki idioma. Kirish parametrlariga asoslangan ob'ektlarni yaratadigan metodga ega sinf.

  package main
  
  import "fmt"
  
  type Product interface {
  	Use()
  }
  
  type ConcreteProductA struct{}
  
  func (p *ConcreteProductA) Use() {
  	fmt.Println("Concrete A mahsulotidan foydalanish")
  }
  
  type ConcreteProductB struct{}
  
  func (p *ConcreteProductB) Use() {
  	fmt.Println("Concrete B mahsulotidan foydalanish")
  }
  
  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()
  }
  

• Fabrika metodi (Factory Method): Ob'ektni yaratish uchun interfeysni belgilaydi, lekin podklasslar qaysi klassni instansiyalashni hal qiladi.

  package main
  
  import "fmt"
  
  // Mahsulot interfeysi
  type Product interface {
  	Operation() string
  }
  
  // Aniq mahsulot A
  type ConcreteProduct1 struct{}
  
  func (p *ConcreteProduct1) Operation() string {
  	return "ConcreteProduct1 natijasi"
  }
  
  // Aniq mahsulot B
  type ConcreteProduct2 struct{}
  
  func (p *ConcreteProduct2) Operation() string {
  	return "ConcreteProduct2 natijasi"
  }
  
  // Yaratuvchi interfeysi
  type Creator interface {
  	FactoryMethod() Product
  	SomeOperation() string
  }
  
  // Asosiy yaratuvchi struktura
  type BaseCreator struct{}
  
  func (bc *BaseCreator) SomeOperation() string {
  	// Mahsulot ob'ektini olish uchun fabrika metodini chaqirish
  	product := bc.FactoryMethod()
  	// Mahsulot bilan ishlash
  	result := "Yaratuvchi: Bir xil yaratuvchining kodi hozirda " + product.Operation()
  	return result
  }
  
  // Aniq yaratuvchi A
  type ConcreteCreator1 struct {
  	BaseCreator
  }
  
  func (cc *ConcreteCreator1) FactoryMethod() Product {
  	return &ConcreteProduct1{} // Aniq mahsulot A ni yaratadi
  }
  
  // Aniq yaratuvchi B
  type ConcreteCreator2 struct {
  	BaseCreator
  }
  
  func (cc *ConcreteCreator2) FactoryMethod() Product {
  	return &ConcreteProduct2{} // Aniq mahsulot B ni yaratadi
  }
  
  func main() {
  	// Foydalanish misoli
  	creator1 := &ConcreteCreator1{}
  	fmt.Println(creator1.SomeOperation())
  
  	creator2 := &ConcreteCreator2{}
  	fmt.Println(creator2.SomeOperation())
  }
  

• Abstrakt fabrika (Abstract Factory): Bog'langan yoki bog'liq bo'lgan ob'ektlar oilalarini yaratish uchun interfeys taqdim etadi, ularning aniq klasslarini ko'rsatmasdan.

  package main
  
  import "fmt"
  
  // Mahsulot A interfeysi
  type AbstractProductA interface {
  	UseProductA() string
  }
  
  // A1 mahsuloti
  type ConcreteProductA1 struct{}
  
  func (*ConcreteProductA1) UseProductA() string {
  	return "A1 mahsulotining natijasi."
  }
  
  // A2 mahsuloti
  type ConcreteProductA2 struct{}
  
  func (*ConcreteProductA2) UseProductA() string {
  	return "A2 mahsulotining natijasi."
  }
  
  // Mahsulot B interfeysi
  type AbstractProductB interface {
  	UseProductB() string
  	AnotherFunctionB(collaborator AbstractProductA) string // Mahsulot A bilan hamkorlik
  }
  
  // B1 mahsuloti
  type ConcreteProductB1 struct{}
  
  func (*ConcreteProductB1) UseProductB() string {
  	return "B1 mahsuloti natijasi."
  }
  
  // B1 bilan hamkorlik
  func (*ConcreteProductB1) AnotherFunctionB(collaborator AbstractProductA) string {
  	result := collaborator.UseProductA()
  	return fmt.Sprintf("B1 natijasi (%s) bilan hamkorlik qilish", result)
  }
  
  // B2 mahsuloti
  type ConcreteProductB2 struct{}
  
  func (*ConcreteProductB2) UseProductB() string {
  	return "B2 mahsuloti natijasi."
  }
  
  // B2 bilan hamkorlik
  func (*ConcreteProductB2) AnotherFunctionB(collaborator AbstractProductA) string {
  	result := collaborator.UseProductA()
  	return fmt.Sprintf("B2 natijasi (%s) bilan hamkorlik qilish", result)
  }
  
  // Abstrakt fabrika interfeysi
  type AbstractFactory interface {
  	CreateProductA() AbstractProductA
  	CreateProductB() AbstractProductB
  }
  
  // Konkret fabrika 1
  type ConcreteFactory1 struct{}
  
  func (*ConcreteFactory1) CreateProductA() AbstractProductA {
  	return &ConcreteProductA1{}
  }
  
  func (*ConcreteFactory1) CreateProductB() AbstractProductB {
  	return &ConcreteProductB1{}
  }
  
  // Konkret fabrika 2
  type ConcreteFactory2 struct{}
  
  func (*ConcreteFactory2) CreateProductA() AbstractProductA {
  	return &ConcreteProductA2{}
  }
  
  func (*ConcreteFactory2) CreateProductB() AbstractProductB {
  	return &ConcreteProductB2{}
  }
  
  // Mijoz kodi, fabrika bilan ishlash
  func ClientCode(factory AbstractFactory) {
  	productA := factory.CreateProductA()
  	productB := factory.CreateProductB()
  
  	fmt.Println(productB.UseProductB())
  	fmt.Println(productB.AnotherFunctionB(productA))
  }
  
  func main() {
  	fmt.Println("Mijoz: Birinchi turdagi fabrikani sinovdan o'tkazish:")
  	ClientCode(&ConcreteFactory1{})
  
  	fmt.Println("Mijoz: Ikkinchi turdagi fabrikani sinovdan o'tkazish:")
  	ClientCode(&ConcreteFactory2{})
  }
  

Asosiy farq Factory Method va Abstract Factory o'rtasida: Factory Method yagona mahsulotlarni yaratadi, Abstract Factory esa mahsulotlar oilalarini.

Pattern nomi	Tavsifi	Qachon foydalaniladi
Oddiy fabrika	Bir sinfdagi metod yordamida turli xil ob'ektlarni yaratish.	Oddiy ob'ektlarni yaratish uchun, fabrika ierarhiyasiga ehtiyoj yo'q.
Factory Method	Ob'ekt yaratish uchun interfeys, podklasslar qaysi klassni instansiyalashni hal qiladi.	Ob'ektlarning turini oldindan bilmaydigan holatlarda.
Abstract Factory	Bog'langan yoki bog'liq bo'lgan ob'ektlar oilalarini yaratish uchun interfeys.	Sistemalar mahsulotlarni yaratish va taqdim etish usulidan mustaqil bo'lishi kerak bo'lsa.

Fabrika shabloni kodning kamroq bog'liqligini ta'minlaydi va yangi mahsulot turlarini qo'shishni osonlashtiradi, mijoz kodini o'zgartirmasdan.