Factory nümunəsi haqqında danış.

Fabrika — bu yaradıcı dizayn nümunəsidir ki, ümumi interfeys təmin edir obyektlərin yaradılması üçün superklassda, altklaslar isə yaradılan obyektlərin növünü dəyişə bilər.

• Sadə Fabrika (Simple Factory): Bu, tam bir nümunə deyil, daha çox bir ifadədir. Parametrlərə əsasən obyektlər yaradan metod olan sinif.

  package main
  
  import "fmt"
  
  type Product interface {
  	Use()
  }
  
  type ConcreteProductA struct{}
  
  func (p *ConcreteProductA) Use() {
  	fmt.Println("Concrete Product A istifadə olunur")
  }
  
  type ConcreteProductB struct{}
  
  func (p *ConcreteProductB) Use() {
  	fmt.Println("Concrete Product B istifadə olunur")
  }
  
  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 Metodu (Factory Method): Interfeys təmin edir obyektin yaradılması üçün, lakin altklaslar hansı sinfi instansiya edəcəyinə qərar verir.

  package main
  
  import "fmt"
  
  // Məhsul interfeysi
  type Product interface {
  	Operation() string
  }
  
  // Konkret məhsul A
  type ConcreteProduct1 struct{}
  
  func (p *ConcreteProduct1) Operation() string {
  	return "ConcreteProduct1-in nəticəsi"
  }
  
  // Konkret məhsul B
  type ConcreteProduct2 struct{}
  
  func (p *ConcreteProduct2) Operation() string {
  	return "ConcreteProduct2-in nəticəsi"
  }
  
  // Yaradıcı interfeysi
  type Creator interface {
  	FactoryMethod() Product
  	SomeOperation() string
  }
  
  // Əsas yaradıcı strukturu
  type BaseCreator struct{}
  
  func (bc *BaseCreator) SomeOperation() string {
  	product := bc.FactoryMethod()
  	result := "Yaradıcı: Eyni kod yalnızca " + product.Operation() + " ilə işləyib"
  	return result
  }
  
  // Konkret yaradıcı A
  type ConcreteCreator1 struct {
  	BaseCreator
  }
  
  func (cc *ConcreteCreator1) FactoryMethod() Product {
  	return &ConcreteProduct1{} // Konkret məhsul A yaradılır
  }
  
  // Konkret yaradıcı B
  type ConcreteCreator2 struct {
  	BaseCreator
  }
  
  func (cc *ConcreteCreator2) FactoryMethod() Product {
  	return &ConcreteProduct2{} // Konkret məhsul B yaradılır
  }
  
  func main() {
  	creator1 := &ConcreteCreator1{}
  	fmt.Println(creator1.SomeOperation())
  
  	creator2 := &ConcreteCreator2{}
  	fmt.Println(creator2.SomeOperation())
  }
  

• Mücərrəd Fabrika (Abstract Factory): Əlaqəli və ya asılı obyekt ailələrini yaratmaq üçün interfeys təmin edir, onların konkret siniflərini göstərmədən.

  package main
  
  import "fmt"
  
  // Məhsul A interfeysi
  type AbstractProductA interface {
  	UseProductA() string
  }
  
  // Konkret məhsul A1
  type ConcreteProductA1 struct{}
  
  func (*ConcreteProductA1) UseProductA() string {
  	return "A məhsulunun nəticəsi."
  }
  
  // Konkret məhsul A2
  type ConcreteProductA2 struct{}
  
  func (*ConcreteProductA2) UseProductA() string {
  	return "A məhsulunun nəticəsi."
  }
  
  // Məhsul B interfeysi
  type AbstractProductB interface {
  	UseProductB() string
  	AnotherFunctionB(collaborator AbstractProductA) string // A məhsulu ilə qarşılıqlı əlaqə
  }
  
  // Konkret məhsul B1
  type ConcreteProductB1 struct{}
  
  func (*ConcreteProductB1) UseProductB() string {
  	return "B məhsulunun nəticəsi."
  }
  
  func (*ConcreteProductB1) AnotherFunctionB(collaborator AbstractProductA) string {
  	result := collaborator.UseProductA()
  	return fmt.Sprintf("B1 məhsulunun (%s) ilə əməkdaşlıq nəticəsi", result)
  }
  
  // Konkret məhsul B2
  type ConcreteProductB2 struct{}
  
  func (*ConcreteProductB2) UseProductB() string {
  	return "B məhsulunun nəticəsi."
  }
  
  func (*ConcreteProductB2) AnotherFunctionB(collaborator AbstractProductA) string {
  	result := collaborator.UseProductA()
  	return fmt.Sprintf("B2 məhsulunun (%s) ilə əməkdaşlıq nəticəsi", result)
  }
  
  // Mücərrəd fabrikanın interfeysi
  type AbstractFactory interface {
  	CreateProductA() AbstractProductA
  	CreateProductB() AbstractProductB
  }
  
  // Konkret fabrikanın 1
  type ConcreteFactory1 struct{}
  
  func (*ConcreteFactory1) CreateProductA() AbstractProductA {
  	return &ConcreteProductA1{}
  }
  
  func (*ConcreteFactory1) CreateProductB() AbstractProductB {
  	return &ConcreteProductB1{}
  }
  
  // Konkret fabrikanın 2
  type ConcreteFactory2 struct{}
  
  func (*ConcreteFactory2) CreateProductA() AbstractProductA {
  	return &ConcreteProductA2{}
  }
  
  func (*ConcreteFactory2) CreateProductB() AbstractProductB {
  	return &ConcreteProductB2{}
  }
  
  // Müştəri kodu, fabrikanın istifadəsi
  func ClientCode(factory AbstractFactory) {
  	productA := factory.CreateProductA()
  	productB := factory.CreateProductB()
  
  	fmt.Println(productB.UseProductB())
  	fmt.Println(productB.AnotherFunctionB(productA))
  }
  
  func main() {
  	fmt.Println("Müştəri: Birinci fabrikanı sınaqdan keçirir:")
  	ClientCode(&ConcreteFactory1{})
  
  	fmt.Println("Müştəri: Eyni müştəri kodunu ikinci fabrikanı sınaqdan keçirir:")
  	ClientCode(&ConcreteFactory2{})
  }
  

Fabrika Metodu və Mücərrəd Fabrika arasındakı əsas fərq: Fabrika Metodu tək məhsulları yaradır, Mücərrəd Fabrika isə məhsul ailələrini.

Nümunə adı	Təsviri	Nə zaman istifadə etmək olar
Sadə Fabrika	Bir sinifdə müxtəlif növ obyektlərin yaradılması üçün metod.	Sadə obyektlərin yaradılması üçün, fabriklərin hierarxiyasına ehtiyac olmadan.
Fabrika Metodu	Obyektin yaradılması üçün interfeys, altklaslar hansı sinfi instansiya edəcəyinə qərar verir.	Sinif hansı obyekt növünü yaradacağını əvvəlcədən bilmədikdə.
Mücərrəd Fabrika	Əlaqəli obyekt ailələrini yaratmaq üçün interfeys təmin edir.	Sistem yaradılma və təqdimat üsulundan asılı olmamalıdır.

Fabrika nümunəsi kodun zəif əlaqəliliyinə kömək edir və yeni məhsul növlərinin əlavə edilməsini asanlaşdırır, müştəri kodunu dəyişmədən.