Aujourd'hui est les premiers jours j'ai oublié, de toute façon, il est de continuer à écrire. Il y a quelques jours aussi nous devons améliorer, et nous nous efforçons de complète aujourd'hui!
Des exemples de ton
En tant que propriétaire d'un magasin de pizza, nous avons besoin de vendre différents types de pizza, donc nous avons besoin de concevoir de nombreux types de pizza, et le besoin d'ajouter du code pour déterminer quels sont les besoins des clients quel genre de pizza, cuits au four, puis emballé à vendre.
Notre pizza est pas statique, il est nécessaire de fournir de nouveaux types, mais il y a des mauvais besoins de pizza de vendre la tablette, cette fois, nous devons modifier le code.
Nous avons donc besoin de créer des objets de la pièce, dans une catégorie distincte, la pizza est de créer un code pour obtenir un autre objet, l'objet créé spécifiquement pour créer un objet de pizza. Ce nouvel objet est ce que nous appelons « l'usine ».
Maintenant que nous avons une usine de simple, donc nous allons créer un objet lorsque la pizza seulement besoin d'appeler une usine de transformation, puis effectuez la cuisson, trancher, opération de boxe. Maintenant, nous devons faire si simple usine de pizza.
code usine simple
super première classe Pizza définit un attribut décrivant leur type, il existe plusieurs méthodes de traitement.
public class Pizza {
String description = "pizza";
public void prepare() {
System.out.println("prepare: " + description);
}
public void bake() {
System.out.println("bake: " + description);
}
public void cut() {
System.out.println("cut: " + description);
}
public void box() {
System.out.println("box: " + description);
System.out.println(description + " successful");
}
}
Pizza définit plusieurs sous-classes que les propriétés Hériter de la classe mère à la modification suivante.
public class CheesePizza extends Pizza {
public CheesePizza() {
this.description = "cheese pizza";
}
}
public class ClamPizza extends Pizza {
public ClamPizza() {
this.description = "clam pizza";
}
}
public class PepperoniPizza extends Pizza {
public PepperoniPizza() {
this.description = "pepperoni pizza";
}
}
public class VeggiePizza extends Pizza {
public VeggiePizza() {
this.description = "veggie pizza";
}
}
code usine pizza simple, le type de pizza par une méthode createPizza (type String), en passant les rendements requis un objet de pizza.
public class SimplePizzaFactory {
public Pizza createPizza(String type) {
Pizza pizza = null;
if (type.equals("cheese")) {
pizza = new CheesePizza();
} else if (type.equals("pepperoni")) {
pizza = new PepperoniPizza();
} else if (type.equals("clam")) {
pizza = new ClamPizza();
} else if (type.equals("veggie")) {
pizza = new VeggiePizza();
}
return pizza;
}
}
Pizzeria Code, y compris une propriété usine de pizza, méthode faire la pizza, en passant un type, conformément à la nécessité de faire de la pizza.
public class PizzaStore {
SimplePizzaFactory factory;
public PizzaStore(SimplePizzaFactory factory) {
this.factory = factory;
}
public Pizza orderPizza(String type) {
Pizza pizza = factory.createPizza(type);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
}
La définition d'une méthode d'essai.
public static void main(String[] args) {
new PizzaStore(new SimplePizzaFactory()).orderPizza("cheese");
}
Pizza est créé, en fait, ah, est tout simplement pas un modèle de conception d'usine , est plus proche d'un habitudes de programmation. En raison de l' utilisation fréquente, il est d' usage de penser comme « un modèle simple de l' usine. »
usine simple éliminant notre magasin de pizza à pizza créer directement des objets de travail, l' usine OEM, mais seulement « utiliser » créer une bonne pizza, modèle simple de l' usine pour obtenir la répartition des responsabilités par cette approche fournit une plante spéciale les objets créés objets nécessaires lors de l' utilisation du produit sans avoir à connaître le nom de classe spécifique, il suffit de fournir une identification spécifique pour créer l'objet correspondant, afin que les utilisateurs ne ont pas besoin de se rappeler le nom de la classe à créer, ce qui élimine quantité inutile de la mémoire .
Cependant, en raison de notre objet usine centralise toute logique pour créer un objet de , Supposons un petit bug, cette grève objet usine, et que tout notre système sera pour cette partie du problème concerné. Il brime le droit « Ouvert - Fermé principe » pour ajouter un nouveau produit, l'usine a dû modifier la logique d'ajouter plus, cette classe d'usine qui serait trop compliqué, et non propice à l'expansion et à l' entretien du système.
Procédé motif usine
Tous les modèles sont utilisés en usine pour créer l'objet de package. modèle de méthode Factory, est en laissant les sous-classes de décider quels objets sont créés, le but du processus est de frapper les objets package créés.
Il y a un créateur haut de la classe abstraite qui définit une méthode abstraite d'usine pour créer une sous - classe de vos pauvres, le créateur contiennent souvent du code qui se fondent sur des produits abstraits, et ces produits abstraits par les sous - classes de fabrication . Créateur n'a pas besoin de savoir où fabriquer des produits spécifiques.
Maintenant, nous regardons le code Pizzeria.
public abstract class PizzaStore {
abstract Pizza createPizza(String item);
public Pizza orderPizza(String type) {
Pizza pizza = createPizza(type);
System.out.println("--- Making a " + pizza.description + "---");
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
}
méthode abstraite createPizza (point String) pour créer un objet sous-classe, et orderPizza (type String) est le créateur de la classe, nous créons l'objet de code d'appel est retourné emballage Pizza fini.
Ensuite, nous regardons le créateur de la classe.
public class ChicagoPizzaStore extends PizzaStore {
@Override
Pizza createPizza(String item) {
if (item.equals("cheese")) {
return new ChicagoStyleCheesePizza();
} else if (item.equals("veggie")) {
return new ChicagoStyleVeggiePizza();
} else if (item.equals("clam")) {
return new ChicagoStyleClamPizza();
} else if (item.equals("pepperoni")) {
return new ChicagoStylePepperoniPizza();
}
return null;
}
}
public class NYPizzaStore extends PizzaStore {
@Override
Pizza createPizza(String item) {
if (item.equals("cheese")) {
return new NYStyleCheesePizza();
} else if (item.equals("clam")) {
return new NYStyleClamPizza();
} else if (item.equals("pepperoni")) {
return new NYStylePepperoniPizza();
} else if (item.equals("veggie")) {
return new NYStyleVeggiePizza();
}
return null;
}
}
Au-dessus de l'héritage de classe pour obtenir la méthode Pizzeria createPizza (point String), créer des objets différents en fonction des différents besoins de pizza, une sous-classe d'objets créés pour les parents utilisent une fabrication de pizza emballage complet est terminé. C'est ce que nous venons de dire les objets dont vous avez besoin pour créer une sous-classe à créer, dans le but de l'emballage pour créer un objet.
Poursuivant notre superclasse, Pizza aiment voir le produit.
public abstract class Pizza {
String description = "Pizza";
void prepare() {
System.out.println("Prepare " + description);
}
void bake() {
System.out.println("Bake " + description);
}
void cut() {
System.out.println("Cut " + description);
}
void box() {
System.out.println("Box " + description);
System.out.println(description + " successful");
}
}
Rien de spécial, il y a un attribut de description pour décrire ce genre de pizza, il y a plusieurs prêts, la cuisson, le découpage et les méthodes d'emballage, orderPizza (type String) dans la superclasse créateur est utilisé. Le code suivant est juste pour nommer deux pizzas et autres, l'autre est toujours le même, il suffit de changer l'attribut de description.
public class ChicagoStyleCheesePizza extends Pizza {
public ChicagoStyleCheesePizza() {
this.description = "Chicago style cheese pizza";
}
}
public class NYStyleClamPizza extends Pizza {
public NYStyleClamPizza() {
description = "NY style clam pizza";
}
}
Enfin, nous examinons la classe de test.
public class Test {
public static void main(String[] args) {
ChicagoPizzaStore chicagoPizzaStore = new ChicagoPizzaStore();
NYPizzaStore nyPizzaStore = new NYPizzaStore();
chicagoPizzaStore.orderPizza("cheese");
System.out.println("-------------------");
chicagoPizzaStore.orderPizza("clam");
System.out.println("-------------------");
chicagoPizzaStore.orderPizza("pepperoni");
System.out.println("-------------------");
chicagoPizzaStore.orderPizza("veggie");
System.out.println("-------------------");
nyPizzaStore.orderPizza("cheese");
System.out.println("-------------------");
nyPizzaStore.orderPizza("clam");
System.out.println("-------------------");
nyPizzaStore.orderPizza("pepperoni");
System.out.println("-------------------");
nyPizzaStore.orderPizza("veggie");
}
}
Il suffit de créer deux objets méthode pizzeria, puis appelez orderPizza (type String), en passant dans la chaîne passée dans le besoin peut obtenir emballés pizza, bien sûr, je ne déclare une variable pour faire référence à la pizza, si nécessaire, seulement vous pouvez déclarer une variable Pizza pizza = nyPizzaStore.orderPizza("veggie").
superclasse de produits et sous leur créateur et super classe et la sous - classe Ils sont parallèles hiérarchie de classes, ce sont des classes abstraites, les classes abstraites ont beaucoup de sous - classes spécifiques, chaque sous - classe a sa propre implémentation spécifique.
Définir le modèle de procédé de l' usine: le modèle de procédé de l' usine définit une interface pour créer des objets, mais la sous - classe à instancier la classe que l' on. Laissez la méthode d'usine de classe à instancier différée aux sous - classes.
La méthode du modèle d'usine peut instancier type de paquet. Dans le créateur abstrait superclasse, il y a d'autres façons de réaliser la méthode de fabrication d'objets peut être utilisé pour créer, mais pour créer des produits pour atteindre cette position est une sous-classe de la méthode abstraite d'usine.
Que les sous-classes qui décident la création objet produit fait référence au créateur de la classe ne connaît pas le produit spécifique qui doit être créé. En fonction du type que lors du choix qui classe pour déterminer la création effective de l'objet qui est le produit.
motif.Procédé usine nécessite beaucoup de répétitions lors de la création du code objet, et le client n'a pas besoin de connaître les circonstances de la façon dont le produit doit être créé. En tant qu'utilisateur, nous avons juste besoin de savoir quelles sont les plantes, ainsi que la nécessité d'identifier ce, afin que nous puissions créer un objet et agréable à utiliser. Inconvénient modèle de méthode de fabrication est très claire, nous pouvons voir à partir du code, vous devez créer une classe facilement monter en flèche, beaucoup, de plus en plus la complexité du système, il peut augmenter la difficulté de comprendre le programmeur.
Dans ce modèle de conception implique également un principe de conception - inversion des dépendances : compter sur abstraite et ne comptez pas sur les classes spécifiques.
Ne peut pas laisser les composants de haut niveau reposent sur des composants de bas niveau, et, quel que soit le niveau ou les composants sous-jacents devraient dépendre de l'abstrait.
Pour notre exemple, est un « Pizzeria composants de haut niveau », et la pizza est « composants de bas niveau », Pizza dépendant des classes abstraites Pizzeria, conformément à nos principes.
Résumé modèle d'usine
Maintenant, notre pizzeria en raison de la très réussie, il doit se joindre à la franchise, et le succès de notre pizza est frais en raison de la grande qualité de nos matières premières, et maintenant nous voulons faire la franchise de pizza aussi selon notre flux de matières premières, donc nous avons augmenté nouveau une usine de matières premières, d'assurer la qualité des matières premières.
look Let à l'interface de l'usine de matières premières.
public interface PizzaIngredientFactory {
public Dough createDough();
public Sauce createSauce();
public Cheese createCheese();
public Veggies[] createVeggies();
public Pepperoni createPepperoni();
public Clams createClam();
}
L'interface d'usine est responsable de la création de toutes les matières premières, notre classe d'usine pour chaque région devrait être une sous-classe de cette classe, et mettre en œuvre chaque méthode pour créer des matières premières.
Nous avons ensuite créé une usine de New York des matières premières, pour obtenir l'interface ci-dessus.
public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
@Override
public Dough createDough() {
return new ThinCrustDough();
}
@Override
public Sauce createSauce() {
return new MarinaraSauce();
}
@Override
public Cheese createCheese() {
return new ReggianoCheese();
}
@Override
public Veggies[] createVeggies() {
Veggies veggies[] = {new Garlic(), new Onion(), new Mushroom(), new RedPepper()};
return veggies;
}
@Override
public Pepperoni createPepperoni() {
return new SlicedPepperoni();
}
@Override
public Clams createClam() {
return new FreshClams();
}
}
Maintenant, créez une superclasse de pizza.
public abstract class Pizza {
String name;
Dough dough;
Sauce sauce;
Veggies[] veggies;
Cheese cheese;
Pepperoni pepperoni;
Clams clams;
abstract void prepare();
void bake() {
System.out.println("Bake for 25 minutes at 350");
}
void cut() {
System.out.println("Cutting the pizza into diagonal slices");
}
void box() {
System.out.println("Place pizza in official PizzaStore box");
}
void setName(String name) {
this.name = name;
}
String getName() {
return name;
}
@Override
public String toString() {
return "Pizza{" +
"name='" + name + '\'' +
", dough=" + dough +
", sauce=" + sauce +
", veggies=" + Arrays.toString(veggies) +
", cheese=" + cheese +
", pepperoni=" + pepperoni +
", clams=" + clams +
'}';
}
}
La pizza, la propriété contient plusieurs, ce sont nos propriétés matières premières, et puis il y a une méthode abstraite prepare (), recueillir nos matières premières, il est l'étape nécessaire pour faire de la pizza.
La prochaine production de plusieurs variétés de pizza.
public class CheesePizza extends Pizza {
PizzaIngredientFactory ingredientFactory;
public CheesePizza(PizzaIngredientFactory ingredientFactory) {
this.ingredientFactory = ingredientFactory;
}
@Override
void prepare() {
System.out.println("Preparing " + name);
dough = ingredientFactory.createDough();
sauce = ingredientFactory.createSauce();
cheese = ingredientFactory.createCheese();
}
}
public class ClamPizza extends Pizza {
PizzaIngredientFactory ingredientFactory;
public ClamPizza(PizzaIngredientFactory ingredientFactory) {
this.ingredientFactory = ingredientFactory;
}
@Override
void prepare() {
System.out.println("Preparing " + name);
dough = ingredientFactory.createDough();
sauce = ingredientFactory.createSauce();
cheese = ingredientFactory.createCheese();
}
}
Il contient un attribut, les propriétés des matières premières végétales, l'utilisation de matières premières dans l'usine afin de créer méthode préparer (). C'est un lieu magique, la matière première de la création et la pizza superclasse séparés, donc complètement les matières premières ne se soucient pas de la classe Pizza est de savoir comment, vous pouvez facilement réutiliser, l'accès aux matières premières est de préparer dans sa mise en œuvre sous-classe ( ) méthodes de co-fondé et les propriétés de la plante. Quand nous avons besoin de ce genre de pizza, la pizza suffit de créer une sous-classe hérite de la superclasse et passer la Pizza Pizza correspondant Factory obtenir la matière première correspondante.
Maintenant, nous allons revenir à la boutique de pizza.
public abstract class PizzaStore {
abstract Pizza createPizza(String item);
public Pizza orderPizza(String type) {
Pizza pizza = createPizza(type);
System.out.println("--- Making a " + pizza.name + "---");
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
}
public abstract class PizzaStore {
abstract Pizza createPizza(String item);
public Pizza orderPizza(String type) {
Pizza pizza = createPizza(type);
System.out.println("--- Making a " + pizza.name + "---");
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
}
public class NYPizzaStore extends PizzaStore {
@Override
Pizza createPizza(String item) {
Pizza pizza = null;
PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();
if (item.equals("cheese")) {
pizza = new CheesePizza(ingredientFactory);
pizza.setName("New York Style Cheese Pizza");
} else if (item.equals("veggie")) {
pizza = new VeggiePizza(ingredientFactory);
pizza.setName("New York Style Veggie Pizza");
} else if (item.equals("clam")) {
pizza = new ClamPizza(ingredientFactory);
pizza.setName("New York Style Clam Pizza");
} else if (item.equals("pepperoni")) {
pizza = new PepperoniPizza(ingredientFactory);
pizza.setName("New York Style Pepperoni Pizza");
}
return pizza;
}
}
New York pizza pizzeria créée par un identifiant correspondant correspondant, mais lorsque vous créez un objet de pizza, la Pizza Pizza Factory a passé l'objet de fournir des matières premières.
Pour résumer le modèle de fabrique abstraite, nous avons introduit un nouveau type de plante, la matière première pour créer une famille de pizza, à travers l'interface fournie par l'usine abstraite, vous pouvez créer une famille de produits, l'utilisation de cette interface pour écrire du code, notre code est découplée de la plante elle-même, afin de pour obtenir une variété de plantes dans des contextes différents, pour fabriquer une variété de produits.
En raison de la façon dont nous créons la matière première est mise en œuvre dans l'usine sous-classe, afin que nous puissions réaliser le remplacement des matières premières en créant une nouvelle classe d'usine.
modèle de fabrique abstraite fournit une interface pour la création de familles d'objets liés ou dépendants sans qu'il soit nécessaire de spécifier explicitement une classe spécifique.
Abstract Factory permet aux clients de créer un groupe de produits d'interface abstraite, sans qu'il soit nécessaire de savoir quel produit spécifique de oui de la production réelle. modèle de fabrique abstraite est la plus grande caractéristique de la famille de produits dans les contraintes de classe interne, mais l'inconvénient est la chose à étendre ces famille de produits est très laborieux, si besoin de nouveaux produits, tous de la classe d'usine presque toutes les modifications, de sorte que le produit la structure de la division à faire preuve de prudence.
Ici, les modèles sont introduits sur plusieurs usines, leur but est de découpler, en cours d'utilisation, pas besoin de faire la distinction entre ce qui est un modèle spécifique, tant que notre objectif est de réduire le degré de couplage peut être atteint.
