Aller aux modèles de conception #Factory

Méthode d'usine

La méthode Factory est un modèle de conception créationnel qui fournit une interface pour créer des objets, mais permet aux sous-classes de modifier le type d'objets qui seront créés. Au lieu d'instancier directement des objets à l'aide de new, la méthode Factory délègue la responsabilité de la création d'objets à des sous-classes ou des méthodes, favorisant ainsi la flexibilité et l'évolutivité.

Énoncé du problème

Quand il est nécessaire de créer des objets, mais que vous ne connaissez pas à l'avance la classe exacte de l'objet qui sera requis. L'application doit gérer différents types d'objets partageant un comportement commun mais différant dans leur implémentation. De plus, vous souhaitez éviter de modifier votre code à chaque fois qu'un nouveau type d'objet est ajouté ou lorsque la façon dont les objets sont créés change.

Problèmes spécifiques qu’il résout

• Création d'objets complexes : l'instanciation directe de classes peut lier votre code à des implémentations spécifiques, le rendant rigide et difficile à maintenir.

• Création d'objet dynamique : dans de nombreux cas, le type d'objet requis peut ne pas être connu avant l'exécution, et cette décision doit être flexible.

• Encapsulation de l'instanciation : la logique de création d'objets doit être séparée du code client, afin que les modifications dans la façon dont les objets sont créés n'affectent pas le reste du système.

• Évolutivité : lorsque vous devez ajouter de nouveaux types de produits (objets), vous souhaitez une solution évolutive qui évite de modifier le code existant.

Exemple concret

Imaginez une usine automobile où vous passez une commande pour une voiture, mais en fonction de vos préférences (par exemple, électrique ou à essence), l'usine assemble et vous fournit le type de voiture approprié. Le client n'a pas besoin de connaître les détails spécifiques de l'assemblage de la voiture : il reçoit simplement le produit.

Mise en œuvre

package main

import (
    "fmt"
    "os"
)

// Step 1: Define the Product Interface
type Car interface {
    Drive() string
    FuelType() string
}

// Step 2: Concrete Products (Electric Car and Gas Car)
type ElectricCar struct{}

func (e *ElectricCar) Drive() string {
    return "Driving an electric car"
}

func (e *ElectricCar) FuelType() string {
    return "Powered by electricity"
}

type GasCar struct{}

func (g *GasCar) Drive() string {
    return "Driving a gas-powered car"
}

func (g *GasCar) FuelType() string {
    return "Powered by gasoline"
}

// Step 3: Define the Factory Interface
type CarFactory interface {
    CreateCar(brand string) Car
}

type carFactory struct{}

func (carFactory *carFactory) CreateCar() Car {
    carPreference := os.Getenv("CAR_PREFERENCE")

    if carPreference == "electric" {
        return &ElectricCar{}
    }

    // here we just instantiate the struct, but you could also 
    // have another functions to help create the object if it's complex
    return &GasCar{}
}

// Step 4: Client Code
func main() {
    // Client uses the factory to create objects
    carFactory := carFactory{}

    // Creating a Gas Car
    gasCar := carFactory.CreateCar()
    fmt.Println(gasCar.Drive())    // Output: Driving a gas-powered car
    fmt.Println(gasCar.FuelType()) // Output: Powered by gasoline

    // Creating an Electric Car
    os.Setenv("CAR_PREFERENCE", "electric")
    electricCar := carFactory.CreateCar()
    fmt.Println(electricCar.Drive())    // Output: Driving an electric car
    fmt.Println(electricCar.FuelType()) // Output: Powered by electricity
}

Interface produit : définit une interface commune (Car) avec les méthodes Drive() et FuelType().

Produits en béton : implémente l'interface avec des classes spécifiques (ElectricCar, GasCar) qui définissent leur comportement.

Factory Interface : Spécifie une méthode (CreateCar()) pour créer des objets Car.

Logique d'usine : l'usine décide quel type de voiture créer en fonction des préférences du client. Ceci est illustré ici en utilisant des variables d'environnement, mais cela pourrait être basé sur n'importe quelle logique.

Code client : demande des voitures à l'usine sans connaître les détails de la création, en utilisant les objets renvoyés via l'interface commune.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!