Factory deseni hakkında bilgi ver.

Fabrika, üst sınıfta nesnelerin oluşturulması için ortak bir arayüz sağlayan, alt sınıfların ise oluşturulan nesne türünü değiştirebildiği bir yaratıcı tasarım desenidir.

• Basit Fabrika (Simple Factory): Tam anlamıyla bir desen değildir, daha çok bir deyimdir. Giriş parametrelerine göre nesneler oluşturan bir sınıf.

  package main
  
  import "fmt"
  
  type Product interface {
  	Use()
  }
  
  type ConcreteProductA struct{}
  
  func (p *ConcreteProductA) Use() {
  	fmt.Println("Concrete Product A kullanılıyor")
  }
  
  type ConcreteProductB struct{}
  
  func (p *ConcreteProductB) Use() {
  	fmt.Println("Concrete Product B kullanılıyor")
  }
  
  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 Yöntemi (Factory Method): Nesne oluşturmak için bir arayüz tanımlar, ancak alt sınıflara hangi sınıfın örnekleneceğine karar verme yetkisi verir.

  package main
  
  import "fmt"
  
  // Ürün arayüzü
  type Product interface {
  	Operation() string
  }
  
  // Somut ürün A
  type ConcreteProduct1 struct{}
  
  func (p *ConcreteProduct1) Operation() string {
  	return "ConcreteProduct1 sonuç"
  }
  
  // Somut ürün B
  type ConcreteProduct2 struct{}
  
  func (p *ConcreteProduct2) Operation() string {
  	return "ConcreteProduct2 sonuç"
  }
  
  // Yaratıcı arayüzü
  type Creator interface {
  	FactoryMethod() Product
  	SomeOperation() string
  }
  
  // Temel yaratıcı yapısı
  type BaseCreator struct{}
  
  func (bc *BaseCreator) SomeOperation() string {
  	// Fabrika metodunu çağırarak ürün nesnesi alınır
  	product := bc.FactoryMethod()
  	// Ürün kullanımı
  	result := "Yaratıcı, " + product.Operation() + " ile çalıştı"
  	return result
  }
  
  // Somut Yaratıcı A
  type ConcreteCreator1 struct {
  	BaseCreator
  }
  
  func (cc *ConcreteCreator1) FactoryMethod() Product {
  	return &ConcreteProduct1{} // Somut ürün A oluşturur
  }
  
  // Somut Yaratıcı B
  type ConcreteCreator2 struct {
  	BaseCreator
  }
  
  func (cc *ConcreteCreator2) FactoryMethod() Product {
  	return &ConcreteProduct2{} // Somut ürün B oluşturur
  }
  
  func main() {
  	// Kullanım örneği
  	creator1 := &ConcreteCreator1{}
  	fmt.Println(creator1.SomeOperation())
  
  	creator2 := &ConcreteCreator2{}
  	fmt.Println(creator2.SomeOperation())
  }
  

• Soyut Fabrika (Abstract Factory): Bağlantılı veya bağımlı nesne aileleri oluşturan bir arayüz sağlar, nesnelerin somut sınıflarını belirtmeden.

  package main
  
  import "fmt"
  
  // Ürün A arayüzü
  type AbstractProductA interface {
  	UseProductA() string
  }
  
  // Somut ürün A1
  type ConcreteProductA1 struct{}
  
  func (*ConcreteProductA1) UseProductA() string {
  	return "A1 ürününün sonucu."
  }
  
  // Somut ürün A2
  type ConcreteProductA2 struct{}
  
  func (*ConcreteProductA2) UseProductA() string {
  	return "A2 ürününün sonucu."
  }
  
  // Ürün B arayüzü
  type AbstractProductB interface {
  	UseProductB() string
  	AnotherFunctionB(collaborator AbstractProductA) string // Ürün A ile etkileşim
  }
  
  // B1 somut ürünü
  type ConcreteProductB1 struct{}
  
  func (*ConcreteProductB1) UseProductB() string {
  	return "B1 ürününün sonucu."
  }
  
  // B1 ile herhangi bir AbstractProductA türüyle etkileşim
  func (*ConcreteProductB1) AnotherFunctionB(collaborator AbstractProductA) string {
  	result := collaborator.UseProductA()
  	return fmt.Sprintf("B1, (%s) ile işbirliği yapıyor", result)
  }
  
  // B2 somut ürünü
  type ConcreteProductB2 struct{}
  
  func (*ConcreteProductB2) UseProductB() string {
  	return "B2 ürününün sonucu."
  }
  
  // B2 ile herhangi bir AbstractProductA türüyle etkileşim
  func (*ConcreteProductB2) AnotherFunctionB(collaborator AbstractProductA) string {
  	result := collaborator.UseProductA()
  	return fmt.Sprintf("B2, (%s) ile işbirliği yapıyor", result)
  }
  
  // Soyut fabrika arayüzü
  type AbstractFactory interface {
  	CreateProductA() AbstractProductA
  	CreateProductB() AbstractProductB
  }
  
  // Somut fabrika 1
  type ConcreteFactory1 struct{}
  
  func (*ConcreteFactory1) CreateProductA() AbstractProductA {
  	return &ConcreteProductA1{}
  }
  
  func (*ConcreteFactory1) CreateProductB() AbstractProductB {
  	return &ConcreteProductB1{}
  }
  
  // Somut fabrika 2
  type ConcreteFactory2 struct{}
  
  func (*ConcreteFactory2) CreateProductA() AbstractProductA {
  	return &ConcreteProductA2{}
  }
  
  func (*ConcreteFactory2) CreateProductB() AbstractProductB {
  	return &ConcreteProductB2{}
  }
  
  // Müşteri kodu, fabrika ile çalışır
  func ClientCode(factory AbstractFactory) {
  	productA := factory.CreateProductA()
  	productB := factory.CreateProductB()
  
  	fmt.Println(productB.UseProductB())
  	fmt.Println(productB.AnotherFunctionB(productA))
  }
  
  func main() {
  	fmt.Println("Müşteri: İlk fabrika tipi ile müşteri kodunu test ediyor:")
  	ClientCode(&ConcreteFactory1{})
  
  	fmt.Println("Müşteri: Aynı müşteri kodunu ikinci fabrika tipi ile test ediyor:")
  	ClientCode(&ConcreteFactory2{})
  }
  

Fabrika yöntemi ile soyut fabrika arasındaki temel fark: Fabrika yöntemi tekil ürünler oluştururken, soyut fabrika ürün aileleri oluşturur.

Desen Adı	Açıklama	Ne zaman kullanılır
Basit Fabrika	Bir sınıfta farklı türde nesneler oluşturan yöntem.	Basit nesne oluşturma durumları için, fabrika hiyerarşisine gerek yoksa.
Fabrika Yöntemi	Nesne oluşturmak için arayüz sağlar, alt sınıflara hangi sınıfın örnekleneceğine karar verme yetkisi verir.	Bir sınıf, oluşturacağı nesne türünü önceden bilmiyorsa.
Soyut Fabrika	İlişkili nesne aileleri oluşturmak için arayüz sağlar.	Sistem, ürünlerin oluşturulma ve temsil edilme şeklinden bağımsız olmalıysa.

Fabrika deseni, kodun zayıf bağlı olmasını teşvik eder ve yeni ürün türlerinin eklenmesini, müşteri kodunu değiştirmeden kolaylaştırır.