Explication détaillée du modèle d'usine Java : usine simple, méthode d'usine et usine abstraite

Explication détaillée du modèle d'usine Java : usine simple, méthode d'usine et usine abstraite

Le modèle d'usine est un modèle de conception couramment utilisé, qui est utilisé pour créer dynamiquement des objets en fonction de différents besoins, séparer la création et l'utilisation d'objets, et améliorer la réutilisabilité et l’évolutivité du code. En Java, il existe trois formes principales de modèle d'usine : l'usine simple, la méthode d'usine et l'usine abstraite.

1. Modèle d'usine simple
Le modèle d'usine simple est le modèle d'usine le plus basique et la forme la plus simple. Il crée des objets via une classe d'usine et détermine le type d'objet à créer en fonction de différents paramètres.

Tout d’abord, définissez une classe de produits abstraite dont héritent toutes les classes de produits concrètes. Créez ensuite une classe d'usine contenant une méthode statique qui renvoie le produit spécifique correspondant en fonction de différents paramètres.

Ce qui suit est un exemple de code qui simule le processus de production automobile :

// 定义抽象产品类
abstract class Car {
    public abstract void produce();
}

// 定义具体产品类
class BenzCar extends Car {
    public void produce() {
        System.out.println("生产奔驰汽车");
    }
}

class BMWCar extends Car {
    public void produce() {
        System.out.println("生产宝马汽车");
    }
}

// 实现工厂类
class CarFactory {
    public static Car createCar(String brand) {
        if (brand.equals("Benz")) {
            return new BenzCar();
        } else if (brand.equals("BMW")) {
            return new BMWCar();
        } else {
            throw new IllegalArgumentException("Unsupported brand:" + brand);
        }
    }
}

// 测试代码
public class SimpleFactoryPatternDemo {
    public static void main(String[] args) {
        Car benz = CarFactory.createCar("Benz");
        benz.produce();

        Car bmw = CarFactory.createCar("BMW");
        bmw.produce();
    }
}

En appelant la méthode CarFactory.createCar, des objets automobiles de différentes marques peuvent être créés selon différents paramètres.

L'avantage du modèle d'usine simple est qu'il est facile à comprendre et adapté à des scénarios simples. Mais l’inconvénient est que cela viole le principe d’ouverture et de fermeture. Lorsqu’un nouveau produit est ajouté, le code de la classe usine doit être modifié.

2. Modèle de méthode d'usine
Le modèle de méthode d'usine est une extension du modèle d'usine simple. Il introduit une classe d'usine abstraite pour définir des méthodes, et la création de produits spécifiques est implémentée par des classes d'usine de sous-classe. Chaque classe d'usine à béton n'est responsable que de la création d'un seul type de produit.

Tout d'abord, définissez une classe de produits abstraite, qui est également héritée par toutes les classes de produits concrètes. Créez ensuite une classe d’usine abstraite contenant une méthode abstraite pour créer des produits. Chaque classe d'usine à béton est chargée de créer un produit.

Ce qui suit est un exemple de code qui simule le processus de production de téléphones mobiles :

// 定义抽象产品类
abstract class Phone {
    public abstract void produce();
}

// 定义具体产品类
class ApplePhone extends Phone {
    public void produce() {
        System.out.println("生产苹果手机");
    }
}

class HuaweiPhone extends Phone {
    public void produce() {
        System.out.println("生产华为手机");
    }
}

// 定义抽象工厂类
abstract class PhoneFactory {
    public abstract Phone createPhone();
}

// 定义具体工厂类
class ApplePhoneFactory extends PhoneFactory {
    public Phone createPhone() {
        return new ApplePhone();
    }
}

class HuaweiPhoneFactory extends PhoneFactory {
    public Phone createPhone() {
        return new HuaweiPhone();
    }
}

// 测试代码
public class FactoryMethodPatternDemo {
    public static void main(String[] args) {
        PhoneFactory appleFactory = new ApplePhoneFactory();
        Phone applePhone = appleFactory.createPhone();
        applePhone.produce();

        PhoneFactory huaweiFactory = new HuaweiPhoneFactory();
        Phone huaweiPhone = huaweiFactory.createPhone();
        huaweiPhone.produce();
    }
}

En implémentant différentes classes d'usine spécifiques, chaque classe d'usine est responsable de la création d'un type d'objet de téléphone mobile. En utilisant le modèle de méthode d'usine, vous pouvez facilement ajouter d'autres séries de produits sans modifier le code existant.

L'avantage du modèle de méthode d'usine est qu'il est conforme au principe ouvert et fermé. Chaque classe d'usine spécifique n'est responsable que de la création d'un seul produit et est facile à développer. Mais l’inconvénient est que cela augmente la complexité du système et nécessite de définir une classe d’usine spécifique pour chaque produit.

3. Modèle d'usine abstrait
Le modèle d'usine abstrait est une extension continue du modèle de méthode d'usine. Il introduit une classe d'usine abstraite pour définir un ensemble de méthodes, chaque méthode est responsable de la création d'une série de produits. Chaque classe d'usine à béton est chargée de créer une famille de produits.

Tout d’abord, définissez une classe de produits abstraite et une classe d’usine abstraite. Chaque classe d’usine abstraite contient plusieurs méthodes abstraites pour créer des produits. Ensuite, créez des classes de produits spécifiques et des classes d'usine spécifiques, et implémentez respectivement des classes de produits abstraites et des classes d'usine.

Ce qui suit est un exemple de code qui simule le processus de production de téléviseurs et de réfrigérateurs :

// 定义抽象产品类
abstract class TV {
    public abstract void produce();
}

abstract class Refrigerator {
    public abstract void produce();
}

// 定义具体产品类
class SamsungTV extends TV {
    public void produce() {
        System.out.println("生产三星电视");
    }
}

class TCLTV extends TV {
    public void produce() {
        System.out.println("生产TCL电视");
    }
}

class HaierRefrigerator extends Refrigerator {
    public void produce() {
        System.out.println("生产海尔冰箱");
    }
}

class GreeRefrigerator extends Refrigerator {
    public void produce() {
        System.out.println("生产格力冰箱");
    }
}

// 定义抽象工厂类
abstract class ApplianceFactory {
    public abstract TV createTV();
    public abstract Refrigerator createRefrigerator();
}

// 定义具体工厂类
class SamsungFactory extends ApplianceFactory {
    public TV createTV() {
        return new SamsungTV();
    }

    public Refrigerator createRefrigerator() {
        return new HaierRefrigerator();
    }
}

class TCLFactory extends ApplianceFactory {
    public TV createTV() {
        return new TCLTV();
    }

    public Refrigerator createRefrigerator() {
        return new GreeRefrigerator();
    }
}

// 测试代码
public class AbstractFactoryPatternDemo {
    public static void main(String[] args) {
        ApplianceFactory samsungFactory = new SamsungFactory();
        TV samsungTV = samsungFactory.createTV();
        Refrigerator haierRefrigerator = samsungFactory.createRefrigerator();
        samsungTV.produce();
        haierRefrigerator.produce();

        ApplianceFactory tclFactory = new TCLFactory();
        TV tclTV = tclFactory.createTV();
        Refrigerator greeRefrigerator = tclFactory.createRefrigerator();
        tclTV.produce();
        greeRefrigerator.produce();
    }
}

En implémentant différentes classes d'usines concrètes, chaque classe d'usines concrètes est responsable de la création d'une série de produits. En utilisant le modèle d'usine abstrait, vous pouvez facilement ajouter d'autres séries de produits sans modifier le code existant.

L'avantage du motif d'usine abstrait est qu'il est conforme au principe ouvert et fermé, qu'il est facile à étendre et qu'il peut maintenir la corrélation entre les produits. Mais l'inconvénient est que lors de l'ajout d'une nouvelle série de produits, le code de la classe d'usine abstraite doit être modifié.

Résumé :
Le modèle d'usine est un modèle de conception couramment utilisé pour créer dynamiquement des objets en fonction de différents besoins. Il existe trois principaux modèles d'usine en Java : l'usine simple, la méthode d'usine et l'usine abstraite. Le modèle d'usine simple est la forme la plus basique.Le modèle de méthode d'usine introduit la classe d'usine abstraite sur sa base. Le modèle d'usine abstraite étend le modèle de méthode d'usine et introduit un ensemble de méthodes pour créer une série de produits. Selon des scénarios et des exigences d'application spécifiques, le choix du modèle d'usine approprié peut améliorer la réutilisation 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!