Une analyse approfondie des trois différentes formes de modèle d'usine Java

Le modèle d'usine Java est un modèle de conception pour créer des objets. Il résume le processus de création d'objet afin qu'il puisse décider quelle classe spécifique instancier au moment de l'exécution. Cela rend le code plus maintenable, flexible et extensible en séparant la logique d'instanciation du code client. Il existe trois variantes courantes du modèle d'usine, à savoir le modèle d'usine simple, le modèle de méthode d'usine et le modèle d'usine abstrait. Ces trois variantes seront analysées en détail ci-dessous et des exemples de codes spécifiques seront fournis.

1. Modèle d'usine simple

Le modèle d'usine simple (Simple Factory Pattern) est également appelé modèle d'usine statique. C'est la forme la plus simple du modèle d'usine. Dans le modèle d'usine simple, nous plaçons la logique de création d'objets dans une classe d'usine simple et créons des objets en appelant les méthodes statiques de la classe d'usine. Le modèle d'usine simple convient aux situations dans lesquelles les types d'objets créés sont relativement petits et ne changent pas fréquemment.

// 抽象产品类
public abstract class Product {
    public abstract void use();
}

// 具体产品类A
public class ProductA extends Product {
    @Override
    public void use() {
        System.out.println("Product A is used.");
    }
}

// 具体产品类B
public class ProductB extends Product {
    @Override
    public void use() {
        System.out.println("Product B is used.");
    }
}

// 简单工厂类
public class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ProductA();
        } else if ("B".equals(type)) {
            return new ProductB();
        } else {
            throw new IllegalArgumentException("Unsupported product type: " + type);
        }
    }
}

// 测试代码
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.use(); // Output: Product A is used.

        Product productB = SimpleFactory.createProduct("B");
        productB.use(); // Output: Product B is used.
    }
}

2. Modèle de méthode d'usine

Le modèle de méthode d'usine délègue la logique d'instanciation aux sous-classes et retarde la création d'objets aux sous-classes. Chaque produit spécifique correspond à une usine spécifique, et le client crée le produit en appelant la méthode de l'usine spécifique. Le modèle de méthode d'usine convient aux situations dans lesquelles de nombreux types d'objets sont créés et nécessitent une expansion flexible.

// 抽象产品类
public abstract class Product {
    public abstract void use();
}

// 具体产品类A
public class ProductA extends Product {
    @Override
    public void use() {
        System.out.println("Product A is used.");
    }
}

// 具体产品类B
public class ProductB extends Product {
    @Override
    public void use() {
        System.out.println("Product B is used.");
    }
}

// 抽象工厂类
public abstract class Factory {
    public abstract Product createProduct();
}

// 具体工厂类A
public class FactoryA extends Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

// 具体工厂类B
public class FactoryB extends Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

// 测试代码
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new FactoryA();
        Product productA = factoryA.createProduct();
        productA.use(); // Output: Product A is used.

        Factory factoryB = new FactoryB();
        Product productB = factoryB.createProduct();
        productB.use(); // Output: Product B is used.
    }
}

3. Modèle d'usine abstrait

Le modèle d'usine abstrait est une extension supplémentaire du modèle de méthode d'usine dans le modèle d'usine abstrait, une usine spécifique peut créer une série de produits associés. Le client crée des produits en appelant les méthodes d'usines spécifiques. Différentes usines spécifiques peuvent créer différentes combinaisons de produits. Le modèle d'usine abstrait convient aux situations dans lesquelles une série de produits connexes doivent être créés et où la cohérence doit être maintenue.

// 抽象产品类A
public abstract class ProductA {
    public abstract void use();
}

// 具体产品类A1
public class ProductA1 extends ProductA {
    @Override
    public void use() {
        System.out.println("Product A1 is used.");
    }
}

// 具体产品类A2
public class ProductA2 extends ProductA {
    @Override
    public void use() {
        System.out.println("Product A2 is used.");
    }
}

// 抽象产品类B
public abstract class ProductB {
    public abstract void use();
}

// 具体产品类B1
public class ProductB1 extends ProductB {
    @Override
    public void use() {
        System.out.println("Product B1 is used.");
    }
}

// 具体产品类B2
public class ProductB2 extends ProductB {
    @Override
    public void use() {
        System.out.println("Product B2 is used.");
    }
}

// 抽象工厂类
public abstract class AbstractFactory {
    public abstract ProductA createProductA();

    public abstract ProductB createProductB();
}

// 具体工厂类1
public class ConcreteFactory1 extends AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}

// 具体工厂类2
public class ConcreteFactory2 extends AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB2();
    }
}

// 测试代码
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        productA1.use(); // Output: Product A1 is used.
        ProductB productB1 = factory1.createProductB();
        productB1.use(); // Output: Product B1 is used.

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        productA2.use(); // Output: Product A2 is used.
        ProductB productB2 = factory2.createProductB();
        productB2.use(); // Output: Product B2 is used.
    }
}

Grâce aux exemples de code ci-dessus, vous pouvez voir clairement les scénarios d'implémentation et d'application spécifiques du modèle d'usine simple, du modèle de méthode d'usine et du modèle d'usine abstrait. Dans le développement réel, nous pouvons choisir un modèle d'usine approprié pour créer des objets en fonction de besoins spécifiques afin d'obtenir la maintenabilité, la flexibilité et l'évolutivité du code.

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!