Abstract Factory
Abstract Factory (Abstract Factory Pattern) è stato creato intorno un super impianto altre piante. La pianta è conosciuta anche come super fabbrica di altre fabbriche. Questo tipo di modelli di progettazione appartengono creare schema, che fornisce il modo migliore per creare oggetti.
Nel Abstract Factory, l'interfaccia è responsabile della creazione di un relativo impianto di oggetti, senza specificare in modo esplicito le loro classi. Ogni oggetto generato, secondo la fabbrica può fornire il modello di fabbrica.
introduzione
Intento: per creare una serie di un'interfaccia oggetti correlati o dipendenti, senza specificare le classi concrete.
Principalmente per risolvere: Il problema principale delle opzioni di interfaccia.
Quando utilizzare: prodotti di sistema hanno più di una famiglia di prodotti, e l'unico sistema in cui una famiglia di prodotti di consumo.
Come risolvere: in una famiglia di prodotti all'interno, definire più prodotti.
Il codice chiave: aggregare più prodotti simili in una fabbrica.
Esempi di applicazione: il lavoro, al fine di prendere parte ad alcune riunioni, ci devono essere due o più set di vestiti che, per esempio, abbigliamento di affari (set completi, una serie di prodotti specifici), vestito da modo (set completi, una serie di prodotti specifici), anche per una famiglia si può avere un donne di affari, uomini d'affari di, moda donna, moda maschile, essi sono anche set completi, vale a dire una serie di prodotti specifici.Supponiamo che una situazione (in realtà non esiste, o altro, non il comunismo, ma a favore del Abstract Factory descrizione modello), in casa, un guardaroba (fabbrica di cemento) può memorizzare solo un uno di questi vestiti (set completi, una serie di prodotti specifici), ogni volta che si prende questo set di vestiti dall'armadio naturalmente portati fuori. Con OO pensiero per capire, tutto il guardaroba (impianti di betonaggio) sono armadi classe (fabbrica abstract) uno, e ciascuna serie di vestiti e compreso il rivestimento specifico (un prodotto particolare), pantaloni (una determinata del prodotto), questi sono infatti giacca camicia specifiche (prodotti astratte), pantaloni specifici sono i pantaloni (un altro prodotto abstract).
Pro: Quando una famiglia di prodotti più oggetti sono progettati per lavorare insieme, possiamo assicurare che il cliente utilizza sempre solo gli stessi oggetti famiglia di prodotti.
Svantaggi: Extended famiglia di prodotti è molto difficile, per aumentare la gamma di un prodotto, sia in astratto creatore codice Riga, ma anche per aggiungere un codice specifico all'interno.
scenari di utilizzo: 1, QQ per la pelle, un insieme di cambiamento insieme.2, generare un procedure diverse del sistema operativo.
Nota: La famiglia diprodotti estesa è difficile, facile da espandere il livello del prodotto.
realizzazione
Creeremo laformaeilcolore interfaccia interfaccia e implementazione di classe di queste entità. Il passo successivo è quello di creare una classe factory astrattaAbstractFactory.Quindi definire laShapeFactoryclasse di fabbrica eColorFactory,queste due classi sono fabbrica ampliatoAbstractFactory.Quindi creare una classeFactoryProducerfabbrica creatore /costruttore.
AbstractFactoryPatternDemo,i nostri corsi dimostrativi utilizzandoFactoryProducerottenere l'oggettoAbstractFactory.Si passa formaFormainformazioni(cerchi / rettangoli / quadrati)perAbstractFactory,ha bisogno di ottenere il tipo di oggetto. Si passa anche informazioni sul colorecolore(rosso / verde / blu) perAbstractFactory,ha bisogno di ottenere il tipo di oggetto.
fase 1
Interfaccia per creare una forma.
Shape.java
Forma interfaccia pubblica {
void draw ();
}
fase 2
Creare classe di entità che implementa l'interfaccia.
Rectangle.java
public class Rettangolo implementa Shape {
@Override
draw public void () {
( "Metodo all'interno rettangolo :: draw ().") System.out.println;
}
}
Square.java
public class Piazza implementa Shape {
@Override
draw public void () {
( "Metodo all'interno Piazza :: draw ().") System.out.println;
}
}
Circle.java
public class Circle implementa Shape {
@Override
draw public void () {
( "Metodo all'interno Circle :: draw ().") System.out.println;
}
}
fase 3
Creare un'interfaccia per colore.
Color.java
interfaccia pubblica di colore {
riempimento void ();
}
fase 4
Creare classe di entità che implementa l'interfaccia.
Red.java
public class Red implementa colori {
@Override
public void fill () {
( "Metodo all'interno Red :: riempimento ().") System.out.println;
}
}
Green.java
public class Verde implementa colori {
@Override
public void fill () {
( "Metodo all'interno Verde :: riempimento ().") System.out.println;
}
}
Blue.java
public class Blu implementa colori {
@Override
public void fill () {
( "Metodo all'interno blu :: riempimento ().") System.out.println;
}
}
fase 5
Creare una classe astratta per il colore e la forma degli oggetti per ottenere la fabbrica.
AbstractFactory.java
classe astratta pubblica AbstractFactory {
Estratto di colore getColor (colore String);
Abstract forma getShape (forma String);
}
passo 6
Creare estesa classe factory AbstractFactory, entità generazione oggetto di classe sulla base delle informazioni fornite.
ShapeFactory.java
public class ShapeFactory estende AbstractFactory {
@Override
pubblico Forma getShape (String shapeType) {
if (shapeType == null) {
restituire null;
}
if (shapeType.equalsIgnoreCase ( "Circle")) {
return new Circle ();
} Else if (shapeType.equalsIgnoreCase ( "Rettangolo")) {
return new Rectangle ();
} Else if (shapeType.equalsIgnoreCase ( "Square")) {
restituire nuova Square ();
}
restituire null;
}
@Override
Colore getColor (colore String) {
restituire null;
}
}
ColorFactory.java
public class ColorFactory estende AbstractFactory {
@Override
pubblico Forma getShape (String shapeType) {
restituire null;
}
@Override
Colore getColor (colore String) {
if (color == null) {
restituire null;
}
if (color.equalsIgnoreCase ( "Rosso")) {
restituire nuova Red ();
} Else if (color.equalsIgnoreCase ( "verde")) {
tornare New Green ();
} Else if (color.equalsIgnoreCase ( "BLU")) {
ritornare nuovo Blue ();
}
restituire null;
}
}
passo 7
Creazione di una fabbrica di categoria creatore / costruttore, passando attraverso l'informazione forma o colore per ottenere la fabbrica.
FactoryProducer.java
public class FactoryProducer {
getFactory AbstractFactory public static (scelta String) {
if (choice.equalsIgnoreCase ( "forma")) {
restituire nuova ShapeFactory ();
} Else if (choice.equalsIgnoreCase ( "COLOR")) {
restituire nuova ColorFactory ();
}
restituire null;
}
}
step 8
Utilizzare FactoryProducer arrivare AbstractFactory, per ottenere l'oggetto della classe passando le informazioni sul tipo di entità.
AbstractFactoryPatternDemo.java
public class AbstractFactoryPatternDemo {
Main (string [] args) {public static void
// Ottenere la forma fabbrica AbstractFactory shapeFactory = FactoryProducer.getFactory ( "forma");
// Ottenere oggetto forma figura del cerchio Shape1 = shapeFactory.getShape ( "CIRCLE");
// Chiamare il metodo draw di shape1.draw Circle ();
// Ottenere oggetto forma Rettangolo shape2 = shapeFactory.getShape ( "Rettangolo");
// Chiamare il metodo draw di shape2.draw Rettangolo ();
// Get forma dell'oggetto Quadrato shape3 = shapeFactory.getShape ( "Square");
// Chiamare il metodo draw Piazza shape3.draw ();
// Ottiene Fabbriche colore AbstractFactory colorFactory = FactoryProducer.getFactory ( "COLOR");
// Prendi il colore dell'oggetto è di colore rosso color1 = colorFactory.getColor ( "RED");
// Chiama il metodo Fill color1.fill Rosso ();
// Ottenere oggetto di colore di colore verde color2 = colorFactory.getColor ( "Verde");
// Chiamare il metodo di riempimento color2.fill di Green ();
// Ottenere oggetto blu colore color3 = colorFactory.getColor ( "BLU");
// Chiama il metodo Fill color3.fill Blu ();
}
}
passo 9
Verifica uscita.
All'interno metodo Circle :: draw (). metodo all'interno rettangolo :: draw (). All'interno metodo Piazza :: draw (). metodo all'interno Red :: riempimento (). All'interno metodo Verde :: riempimento (). All'interno metodo Blu :: riempimento ().