Fabrique Abstraite
Abstract Factory (Abstract Pattern usine) est créé autour d'un super-plantes d'autres plantes. La plante est également connue en tant que super autres usines usine. Ce type de modèles de conception appartiennent create schema, qui fournit la meilleure façon de créer des objets.
Dans le modèle de fabrique abstraite, l'interface est responsable de la création d'un objet de plantes liées, sans spécifier explicitement leurs classes. Chaque objet généré, selon l'usine peut fournir le modèle d'usine.
introduction
Intention: pour créer une série d'interface objets associés ou dépendants, sans préciser leurs classes concrètes.
Principalement pour résoudre: Le principal problème des options d'interface.
Quand utiliser: Produits système ont plus d'une famille de produits, et le seul système dans lequel une famille de produits de consommation.
Comment fixer: dans une famille de produit à l' intérieur, de définir les produits multiples.
Le code clé: plusieurs produits semblables agrégés dans une usine.
Exemples d'application: le travail, afin de prendre part à certaines réunions, il doit y avoir deux ou plusieurs ensembles de vêtements il, par exemple, une tenue d'affaires (des ensembles complets, une série de produits spécifiques), robe de mode (ensembles complets, une série de produits spécifiques), même pour une famille Vous pouvez avoir une entreprise des femmes, des hommes d'affaires de, la mode féminine, la mode masculine, ils sont aussi des ensembles complets, à savoir une série de produits spécifiques.Supposons une situation (en réalité n'existe pas, ou bien, pas le communisme, mais en faveur de l'abstrait usine Description du motif), dans votre maison, une garde-robe (usine de béton) ne peut stocker un tel des vêtements (ensembles complets, une série de produits spécifiques), chaque fois que vous prenez cette série de vêtements de la garde-robe naturellement pris. Avec OO penser à comprendre, tous les garde-robe (centrale à béton) sont des armoires de classe (fabrique abstraite) un, et chacun un ensemble de vêtements et comprenant veste spécifique (un produit particulier), un pantalon (un particulier produit), ceux-ci sont en fait veste chemise spécifique (produits abstraits), pantalons spécifiques sont un pantalon (un autre produit abstrait).
Avantages: Quand une famille de produits plusieurs objets sont conçus pour fonctionner ensemble, nous pouvons nous assurer que le client utilise toujours exactement les mêmes objets de la famille de produits.
Inconvénients: la famille de produits élargie est très difficile, pour augmenter une gamme d'un produit, à la fois dans le code Riga Créateur abstrait, mais aussi d'ajouter un code spécifique à l' intérieur.
Scénarios d' utilisation: 1, QQpour la peau, un ensemble de changements ensemble. 2, générer une des procédures différentes du système d'exploitation.
Note: La famille de produits étendue est difficile, facile à étendre le niveau du produit.
réalisation
Nous allons créer l'interface interface et la mise en œuvre de classeformeet lacouleurde ces entités. L'étape suivante consiste à créer un résuméAbstractFactoryde classe defabrique.Ensuite , définir laShapeFactoryde classe usine etColorFactory,ces deux classes sont l' usine élargieAbstractFactory.Ensuite , créez une classeFactoryProducercréateur usine /constructeur.
AbstractFactoryPatternDemo,nos classes de démonstration utilisantFactoryProducerpour obtenir l' objetAbstractFactory.Elle passe formeFormed'information(CIRCLE / RECTANGLE / SQUARE)àAbstractFactory,il a besoin d'obtenir le type d'objet. Il passe également de l' information couleurcouleur(rouge / vert / bleu) àAbstractFactory,il a besoin d'obtenir le type d'objet.
Etape 1
Interface pour créer une forme.
Shape.java
public interface Shape {
void draw ();
}
Etape 2
Créer classe d'entité qui implémente l'interface.
Rectangle.java
public class Rectangle implémente Shape {
@Override
tirage public void () {
( "Méthode Inside Rectangle :: draw ().") System.out.println;
}
}
Square.java
public class place implémente Shape {
@Override
tirage public void () {
( "Méthode Inside Place :: draw ().") System.out.println;
}
}
Circle.java
Cercle public class implémente Shape {
@Override
tirage public void () {
( "Méthode Inside Cercle :: draw ().") System.out.println;
}
}
Etape 3
Créer une interface pour la couleur.
Color.java
public interface couleur {
le remplissage de vide ();
}
Etape 4
Créer classe d'entité qui implémente l'interface.
Red.java
public class Red implémente couleur {
@Override
public void fill () {
( "Méthode Inside Red :: fill ().") System.out.println;
}
}
Green.java
public class Vert implémente couleur {
@Override
public void fill () {
( "Méthode Inside vert :: fill ().") System.out.println;
}
}
Blue.java
public class Bleu implémente couleur {
@Override
public void fill () {
( "Méthode Inside Bleu :: fill ().") System.out.println;
}
}
Etape 5
Créer une classe abstraite pour la couleur et la forme des objets pour obtenir l'usine.
AbstractFactory.java
public abstract class AbstractFactory {
abstraite Couleur getColor (couleur String);
Forme abstraite getShape (forme de chaîne);
}
Etape 6
Créer classe de fabrique AbstractFactory étendu, entité génération d'objet de classe basée sur l'information donnée.
ShapeFactory.java
ShapeFactory public class AbstractFactory {
@Override
Forme publique getShape (String shapeType) {
if (shapeType == null) {
return null;
}
if (shapeType.equalsIgnoreCase ( "CIRCLE")) {
return new Cercle ();
} Else if (shapeType.equalsIgnoreCase ( "RECTANGLE")) {
return new Rectangle ();
} Else if (shapeType.equalsIgnoreCase ( "SQUARE")) {
return new Carré ();
}
return null;
}
@Override
Couleur getColor (couleur String) {
return null;
}
}
ColorFactory.java
ColorFactory public class AbstractFactory {
@Override
Forme publique getShape (String shapeType) {
return null;
}
@Override
Couleur getColor (couleur String) {
if (couleur == null) {
return null;
}
if (color.equalsIgnoreCase ( "RED")) {
return new rouge ();
} Else if (color.equalsIgnoreCase ( "VERT")) {
return new Green ();
} Else if (color.equalsIgnoreCase ( "BLUE")) {
return new bleu ();
}
return null;
}
}
Etape 7
Créer une catégorie créateur / constructeur de l'usine, en passant par la forme ou la couleur des informations pour obtenir l'usine.
FactoryProducer.java
public class FactoryProducer {
GetFactory AbstractFactory public static (choix String) {
if (choice.equalsIgnoreCase ( "SHAPE")) {
return new ShapeFactory ();
} Else if (choice.equalsIgnoreCase ( "COLOR")) {
return new ColorFactory ();
}
return null;
}
}
Etape 8
Utilisez FactoryProducer pour obtenir AbstractFactory, pour obtenir l'objet de la classe en passant les informations de type d'entité.
AbstractFactoryPatternDemo.java
public class AbstractFactoryPatternDemo {
main (String [] args) {public static void
// Obtenir la forme d'usine AbstractFactory shapeFactory = FactoryProducer.getFactory ( "SHAPE");
// Obtenir l'objet de forme Forme Cercle shape1 = shapeFactory.getShape ( "CIRCLE");
// Appel de la méthode de tirage de shape1.draw Cercle ();
// Obtenir l'objet forme Rectangle Shape shape2 = shapeFactory.getShape ( "RECTANGLE");
// Appel de la méthode de tirage de shape2.draw Rectangle ();
// Obtenir la forme de l'objet Forme Carré shape3 = shapeFactory.getShape ( "SQUARE");
// Appel de la méthode de tirage Place shape3.draw ();
// Obtenir les usines de couleurs AbstractFactory colorFactory = FactoryProducer.getFactory ( "COLOR");
// Obtenir la couleur de l'objet est de couleur rouge color1 = colorFactory.getColor ( "RED");
// Appel de la méthode de remplissage color1.fill Rouge ();
// Obtenir la couleur de l'objet Vert Couleur couleur2 = colorFactory.getColor ( «vert»);
// Appel de la méthode de remplissage de color2.fill Green ();
// Obtenir la couleur de l'objet Couleur Bleu color3 = colorFactory.getColor ( "BLUE");
// Appel de la méthode de remplissage bleu color3.fill ();
}
}
Etape 9
Vérifiez la sortie.
Méthode intérieur Cercle :: draw (). Méthode Inside Rectangle :: draw (). Méthode Inside Place :: draw (). Méthode Inside Red :: fill (). A l'intérieur méthode verte :: fill (). Méthode Inside Bleu :: fill ().