պատմիր Factory դիզայնի մասին։

Ֆաբրիկա — դա ձևանմուշ է, որը տրամադրում է ընդհանուր ինտերֆեյս օբյեկտների ստեղծման համար սուպերակլասում, մինչդեռ ենթակլասները կարող են փոփոխել ստեղծվող օբյեկտների տեսակը:

• Պարզ ֆաբրիկա (Simple Factory): Չի հանդիսանում լիարժեք ձևանմուշ, այլ ավելի շատ իդեոմա։ Կլաս, որի մեթոդը ստեղծում է օբյեկտներ մուտքային պարամետրերի հիման վրա:

  package main
  
  import "fmt"
  
  type Product interface {
  	Use()
  }
  
  type ConcreteProductA struct{}
  
  func (p *ConcreteProductA) Use() {
  	fmt.Println("Օգտագործում է կոնկրետ արտադրանքը A")
  }
  
  type ConcreteProductB struct{}
  
  func (p *ConcreteProductB) Use() {
  	fmt.Println("Օգտագործում է կոնկրետ արտադրանքը B")
  }
  
  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()
  }
  

• Արտադրության մեթոդ (Factory Method): Դեֆինեացնում է օբյեկտի ստեղծման ինտերֆեյսը, բայց թույլ է տալիս ենթակլասներին որոշել, թե որ դասը պետք է ինստանցավորել:

  package main
  
  import "fmt"
  
  // Օբյեկտի ինտերֆեյս
  type Product interface {
  	Operation() string
  }
  
  // Կոնկրետ արտադրանք A
  type ConcreteProduct1 struct{}
  
  func (p *ConcreteProduct1) Operation() string {
  	return "Արդյունք կոնկրետ արտադրանք 1-ից"
  }
  
  // Կոնկրետ արտադրանք B
  type ConcreteProduct2 struct{}
  
  func (p *ConcreteProduct2) Operation() string {
  	return "Արդյունք կոնկրետ արտադրանք 2-ից"
  }
  
  // Ստեղծողի ինտերֆեյս
  type Creator interface {
  	FactoryMethod() Product
  	SomeOperation() string
  }
  
  // Ստեղծողի բազային կառուցվածք
  type BaseCreator struct{}
  
  func (bc *BaseCreator) SomeOperation() string {
  	// Կոչում է արտադրանքի ստեղծման մեթոդը
  	product := bc.FactoryMethod()
  	// Օգտագործում է արտադրանքը
  	result := "Ստեղծողը. նույն կոդը միայն աշխատեց արտադրանքի հետ " + product.Operation()
  	return result
  }
  
  // կոնկրետ ստեղծող A
  type ConcreteCreator1 struct {
  	BaseCreator
  }
  
  func (cc *ConcreteCreator1) FactoryMethod() Product {
  	return &ConcreteProduct1{} // Ստեղծում է կոնկրետ արտադրանք A
  }
  
  // կոնկրետ ստեղծող B
  type ConcreteCreator2 struct {
  	BaseCreator
  }
  
  func (cc *ConcreteCreator2) FactoryMethod() Product {
  	return &ConcreteProduct2{} // Ստեղծում է կոնկրետ արտադրանք B
  }
  
  func main() {
  	// Օրինակ օգտագործում
  	creator1 := &ConcreteCreator1{}
  	fmt.Println(creator1.SomeOperation())
  
  	creator2 := &ConcreteCreator2{}
  	fmt.Println(creator2.SomeOperation())
  }
  

• Աբստրակտ ֆաբրիկա (Abstract Factory): Պատրաստում է ինտերֆեյս՝ ստեղծելու կապված կամ կախված օբյեկտների ընտանիքներ՝ առանց նշելու կոնկրետ դասերը:

  package main
  
  import "fmt"
  
  // Ապրանքի A ինտերֆեյս
  type AbstractProductA interface {
  	UseProductA() string
  }
  
  // Կոնկրետ ապրանք A1
  type ConcreteProductA1 struct{}
  
  func (*ConcreteProductA1) UseProductA() string {
  	return "A արտադրանքի արդյունքը."
  }
  
  // Կոնկրետ ապրանք A2
  type ConcreteProductA2 struct{}
  
  func (*ConcreteProductA2) UseProductA() string {
  	return "A արտադրանքի արդյունքը."
  }
  
  // Ապրանքի B ինտերֆեյս
  type AbstractProductB interface {
  	UseProductB() string
  	AnotherFunctionB(collaborator AbstractProductA) string // փոխազդեցություն A-ի հետ
  }
  
  // Կոնկրետ ապրանք B1
  type ConcreteProductB1 struct{}
  
  func (*ConcreteProductB1) UseProductB() string {
  	return "B արտադրանքի արդյունքը."
  }
  
  // B1-ի փոխազդեցությունը ցանկացած AbstractProductA տեսակի հետ
  func (*ConcreteProductB1) AnotherFunctionB(collaborator AbstractProductA) string {
  	result := collaborator.UseProductA()
  	return fmt.Sprintf("B1-ի համագործակցությունը (%s)-ի հետ", result)
  }
  
  // Կոնկրետ ապրանք B2
  type ConcreteProductB2 struct{}
  
  func (*ConcreteProductB2) UseProductB() string {
  	return "B արտադրանքի արդյունքը."
  }
  
  // B2-ի փոխազդեցությունը ցանկացած AbstractProductA տեսակի հետ
  func (*ConcreteProductB2) AnotherFunctionB(collaborator AbstractProductA) string {
  	result := collaborator.UseProductA()
  	return fmt.Sprintf("B2-ի համագործակցությունը (%s)-ի հետ", result)
  }
  
  // Աբստրակտ ֆաբրիկայի ինտերֆեյս
  type AbstractFactory interface {
  	CreateProductA() AbstractProductA
  	CreateProductB() AbstractProductB
  }
  
  // կոնկրետ ֆաբրիկա 1
  type ConcreteFactory1 struct{}
  
  func (*ConcreteFactory1) CreateProductA() AbstractProductA {
  	return &ConcreteProductA1{}
  }
  
  func (*ConcreteFactory1) CreateProductB() AbstractProductB {
  	return &ConcreteProductB1{}
  }
  
  // կոնկրետ ֆաբրիկա 2
  type ConcreteFactory2 struct{}
  
  func (*ConcreteFactory2) CreateProductA() AbstractProductA {
  	return &ConcreteProductA2{}
  }
  
  func (*ConcreteFactory2) CreateProductB() AbstractProductB {
  	return &ConcreteProductB2{}
  }
  
  // Հաճախորդի կոդը, որը աշխատում է ֆաբրիկայի հետ
  func ClientCode(factory AbstractFactory) {
  	productA := factory.CreateProductA()
  	productB := factory.CreateProductB()
  
  	fmt.Println(productB.UseProductB())
  	fmt.Println(productB.AnotherFunctionB(productA))
  }
  
  func main() {
  	fmt.Println("Հաճախորդը՝ փորձարկելով հաճախորդի կոդը առաջին ֆաբրիկայի տեսակի հետ:")
  	ClientCode(&ConcreteFactory1{})
  
  	fmt.Println("Հաճախորդը՝ փորձարկելով նույն հաճախորդի կոդը երկրորդ ֆաբրիկայի տեսակի հետ:")
  	ClientCode(&ConcreteFactory2{})
  }
  

Հիմնական տարբերությունը Ֆաբրիկային մեթոդի և Աբստրակտ ֆաբրիկայի միջև՝ Ֆաբրիկային մեթոդը ստեղծում է առանձին արտադրանք, մինչդեռ Աբստրակտ ֆաբրիկան ստեղծում է ընտանիքներ արտադրանք:

Դասավորության անվանումը	Նկարագրություն	Երբ օգտագործել
Պարզ ֆաբրիկա	Մեթոդ մի դասում, որը ստեղծում է տարբեր տիպերի օբյեկտներ։	Պարզ ստեղծելու համար առանց ֆաբրիկայի ժառանգականության։
Ֆաբրիկայի մեթոդ	Ինտերֆեյս՝ օբյեկտի ստեղծման համար, որը թույլ է տալիս ենթակլասներին որոշել, թե որ դասը պետք է ինստանցավորել։	Երբ դասը չի կարող կանխատեսել ստեղծվող օբյեկտների տիպը։
Աբստրակտ ֆաբրիկա	Ինտերֆեյս՝ կապված կամ կախված օբյեկտների ընտանիքներ ստեղծելու համար։	Երբ համակարգը պետք է լինի անկախ ստեղծման և ներկայացման մեթոդներից։

Ֆաբրիկայի ձևանմուշը նպաստում է կոդի թույլ կապին և հեշտացնում է նոր տիպերի արտադրանքի ավելացումը առանց հաճախորդի կոդի փոփոխության։