Quels sont les trois modèles d'usine en Java ?

Les trois modèles d'usine de Java : 1. Modèle d'usine simple, qui fournit une fonction pour créer des instances d'objet sans se soucier de son implémentation spécifique ; 2. Modèle de méthode d'usine 3. Modèle d'usine abstrait, qui fournit un moyen de créer ; une instance d'objet. Une interface pour une famille d'objets liés ou interdépendants sans spécifier leurs classes concrètes.

(Tutoriel recommandé : Tutoriel d'introduction à Java)

1. 🎜>Définition d'une usine simple :

Fournit une fonction pour créer des instances d'objet sans se soucier de son implémentation spécifique. Le type de l'instance créée peut être une interface, une classe abstraite ou une classe concrète

implémentant l'interface de la voiture

public interface Car {
    String getName();
}

Classe Benz

public class Benz implements Car {
    @Override
    public String getName() {
        return "Benz";
    }
}

Type BMW

public class BMW implements Car {
    @Override
    public String getName() {
        return "BMW";
    }
}

Usine simple qui peut produire à la fois des BMW et des Mercedes-Benz

public class SimpleFactory {
    public Car getCar(String name){
        if (name.equals("BMW")){
            return new BMW();
        }else if (name.equals("benz")){
            return new Benz();
        }else {
            System.out.println("不好意思，这个品牌的汽车生产不了");
            return null;
        }
    }
}

Classe de test

public class SimpleFactoryTest {
    public static void main(String[] args){
        SimpleFactory simpleFactory = new SimpleFactory();
        Car car = simpleFactory.getCar("BMW");
        System.out.println(car.getName());
    }
}

Résultat du test

BMW

Selon la définition d'une usine simple, les utilisateurs veulent seulement le produit et ne se soucient pas de la façon dont le Le produit est produit. Il a l'air parfait. Mais réfléchissez-y, existe-t-il des usines dans ce monde qui produisent de tout ?

Évidemment, chaque marque automobile a sa propre usine de production et sa propre technologie de production. En mappant avec le framework Spring, nous avons de nombreux types de beans qui doivent être produits si nous comptons uniquement sur une simple usine pour l'implémenter, combien de if..else if devons-nous imbriquer dans la classe factory ?

Et lorsque nous produisons une voiture dans le code, elle en sort simplement une nouvelle, mais en fonctionnement réel, nous ne savons pas combien d'opérations sont nécessaires. Le chargement, l'enregistrement et d'autres opérations seront reflétés. la classe usine, donc cette classe Cela deviendra chaotique et peu pratique à gérer, donc chaque marque devrait avoir sa propre catégorie de production.

Parce que c'est dédié, c'est professionnel A cette époque, la méthode usine apparaît.

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

Interface d'usine

//定义一个工厂接口，功能就是生产汽车
public interface Factory {
    Car getCar();
}

Usine Mercedes-Benz

public class BenzFactory implements Factory {
    @Override
    public Car getCar() {
        return new Benz();
    }
}

Usine BMW

public class BMWFactory implements Factory{
    @Override
    public Car getCar() {
        return new BMW();
    }
}

Classe de test

public class FactoryTest {
   public static void main(String[] args){
       Factory bmwFactory = new BMWFactory();
       System.out.println(bmwFactory.getCar().getName());
       Factory benzFactory = new BenzFactory();
       System.out.println(benzFactory.getCar().getName());
   }
}

Résultats des tests

BMW
Benz

D'après ce qui précède, le code montre que les voitures de différentes marques sont produites par différentes usines et qu'elles semblent parfaites. Mais si vous regardez la catégorie test, lorsqu'une personne veut acheter une voiture BMW (en supposant qu'il n'y ait pas de vendeur), alors elle doit se rendre à l'usine BMW pour en produire une pour elle, et quelques jours plus tard, elle veut acheter une Mercedes-Benz Lors de l'achat d'une voiture, vous devez vous rendre à l'usine Mercedes-Benz pour embaucher quelqu'un pour la produire, ce qui augmente sans aucun doute la complexité du fonctionnement de l'utilisateur. Alors existe-t-il une méthode conviviale ? A cette époque, le modèle abstrait de l'usine est apparu.

3. Modèle d'usine abstraite

Usine abstraite

public abstract class AbstractFactory {

     protected abstract Car getCar();
     
     //这段代码就是动态配置的功能
     //固定模式的委派
     public Car getCar(String name){
        if("BMW".equalsIgnoreCase(name)){
            return new BmwFactory().getCar();
        }else if("Benz".equalsIgnoreCase(name)){
            return new BenzFactory().getCar();
        }else if("Audi".equalsIgnoreCase(name)){
            return new AudiFactory().getCar();
        }else{
            System.out.println("这个产品产不出来");
            return null;
        }
    }
}

Usine par défaut

public class DefaultFactory extends AbstractFactory {

    private AudiFactory defaultFactory = new AudiFactory();
    
    public Car getCar() {
        return defaultFactory.getCar();
    }

}

Usine BMW

public class BMWFactory extends AbstractFactory {
    @Override
    public Car getCar() {
        return new BMW();
    }
}

Usine Mercedes-Benz

public class BenzFactory extends AbstractFactory {
    @Override    public Car getCar() {
            return new Benz();
    }
}

Classe de test

public class AbstractFactoryTest {
    public static void main(String[] args) {        
        DefaultFactory factory = new DefaultFactory();        
        System.out.println(factory.getCar("Benz").getName());            
    }
}

Résultats des tests

Benz

D'après le code ci-dessus, on peut voir que si l'utilisateur a besoin d'une voiture, il lui suffit d'accéder à la valeur par défaut usine pour présenter ses propres exigences (paramètres entrants), vous pouvez obtenir les produits que vous souhaitez sans avoir à trouver différentes usines de production en fonction des produits, ce qui est pratique à utiliser pour les utilisateurs.

Remarque : certaines personnes se moquent des modèles de conception, et certaines personnes les respectent comme des dieux, mais je suis d'accord avec elles.

D'après ma compréhension approximative, la chose classique à propos des modèles de conception est qu'ils résolvent la douleur à la fois de la personne qui écrit le code et de celle qui appelle le code. Différents modèles de conception sont différents. applicable uniquement à différents scénarios. Quant à savoir s’il faut l’utiliser ou non et comment l’utiliser, vous devez y réfléchir attentivement.

Mais il ne faut pas l'utiliser juste pour le plaisir de l'utiliser. Les subtilités ne peuvent être laissées à chacun qu'à goûter lentement.

Pour plus de connaissances liées à la programmation, veuillez visiter :

Cours de programmation

 ! !

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!