Design Pattern - Abstract Factory Pattern

I modelli di fabbrica astratti funzionano attorno a una super fabbrica che crea altre fabbriche. Questa fabbrica è anche chiamata fabbrica di fabbriche. Questo tipo di modello di progettazione rientra nel modello di creazione poiché questo modello fornisce uno dei modi migliori per creare un oggetto.

In Abstract Factory pattern un'interfaccia è responsabile della creazione di una factory di oggetti correlati senza specificare esplicitamente le loro classi. Ogni factory generata può fornire gli oggetti secondo il pattern Factory.

Implementazione

Creeremo un'interfaccia Shape e una classe concreta che la implementa. Creiamo una classe di fabbrica astratta AbstractFactory come passaggio successivo. Viene definita la classe Factory ShapeFactory, che estende AbstractFactory. Viene creata una classe di creatore / generatore di fabbrica FactoryProducer.

AbstractFactoryPatternDemo, la nostra classe demo utilizza FactoryProducer per ottenere un oggetto AbstractFactory. Passerà le informazioni (CIRCLE / RECTANGLE / SQUARE per Shape) ad AbstractFactory per ottenere il tipo di oggetto di cui ha bisogno.

Passo 1

Crea un'interfaccia per Shapes.

Shape.java

public interface Shape {
   void draw();
}

Passo 2

Crea classi concrete che implementano la stessa interfaccia.

RoundedRectangle.java

public class RoundedRectangle implements Shape {
   @Override
   public void draw() {
      System.out.println("Inside RoundedRectangle::draw() method.");
   }
}

RoundedSquare.java

public class RoundedSquare implements Shape {
   @Override
   public void draw() {
      System.out.println("Inside RoundedSquare::draw() method.");
   }
}

Rectangle.java

public class Rectangle implements Shape {
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}

Passaggio 3

Crea una classe astratta per ottenere fabbriche per oggetti di forma normale e arrotondata.

AbstractFactory.java

public abstract class AbstractFactory {
   abstract Shape getShape(String shapeType) ;
}

Passaggio 4

Crea classi Factory che estendono AbstractFactory per generare oggetti di classi concrete in base alle informazioni fornite.

ShapeFactory.java

public class ShapeFactory extends AbstractFactory {
   @Override
   public Shape getShape(String shapeType){    
      if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();         
      }else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }	 
      return null;
   }
}

RoundedShapeFactory.java

public class RoundedShapeFactory extends AbstractFactory {
   @Override
   public Shape getShape(String shapeType){    
      if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new RoundedRectangle();         
      }else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new RoundedSquare();
      }	 
      return null;
   }
}

Passaggio 5

Crea una classe di generatore / produttore di fabbrica per ottenere le fabbriche passando un'informazione come Forma

FactoryProducer.java

public class FactoryProducer {
   public static AbstractFactory getFactory(boolean rounded){   
      if(rounded){
         return new RoundedShapeFactory();         
      }else{
         return new ShapeFactory();
      }
   }
}

Passaggio 6

Utilizzare FactoryProducer per ottenere AbstractFactory al fine di ottenere fabbriche di classi concrete passando un'informazione come tipo.

AbstractFactoryPatternDemo.java

public class AbstractFactoryPatternDemo {
   public static void main(String[] args) {
      //get shape factory
      AbstractFactory shapeFactory = FactoryProducer.getFactory(false);
      //get an object of Shape Rectangle
      Shape shape1 = shapeFactory.getShape("RECTANGLE");
      //call draw method of Shape Rectangle
      shape1.draw();
      //get an object of Shape Square 
      Shape shape2 = shapeFactory.getShape("SQUARE");
      //call draw method of Shape Square
      shape2.draw();
      //get shape factory
      AbstractFactory shapeFactory1 = FactoryProducer.getFactory(true);
      //get an object of Shape Rectangle
      Shape shape3 = shapeFactory1.getShape("RECTANGLE");
      //call draw method of Shape Rectangle
      shape3.draw();
      //get an object of Shape Square 
      Shape shape4 = shapeFactory1.getShape("SQUARE");
      //call draw method of Shape Square
      shape4.draw();
      
   }
}

Passaggio 7

Verifica l'output.

Inside Rectangle::draw() method.
Inside Square::draw() method.
Inside RoundedRectangle::draw() method.
Inside RoundedSquare::draw() method.