ABSTRACT FACTORY DESIGN PATTERN

Il pattern Abstract Factory consiste in una Factory che crea altre Factory. La Factory è anche chiamata Factory di Factory. Questo tipo di design pattern rientra nei pattern Creazionali poiché fornisce uno dei modi migliori per creare un oggetto.

abstract factory

L’Abstract Factory fornisce un’interfaccia per creare famiglie di oggetti connessi o dipendenti tra loro, in modo che non ci sia necessità da parte dei client di specificare i nomi delle classi concrete all’interno del proprio codice.

In questo modo si permette che un sistema sia indipendente dall’implementazione degli oggetti concreti e che il client, attraverso l’interfaccia, utilizzi diverse famiglie di prodotti.

DIAGRAMMA UML ABSTRACT FACTORY

UML FACTORY

 

IMPLEMENTAZIONE

Creiamo un’interfaccia Figura e una classe concreta che la implementa. Creiamo una classe AbstractFactory. Definiamo FiguraFactory e GenericFactory, che estendono AbstractFactory. Dopo di chè creiamo un FactoryProducer che servirà per generare la factory opportuna. La classe Main utilizza il FactoryProducer per ottenere un oggetto di tipo AbstractFactory. Sarà compito della factory opportuna generare gli oggetti desiderati.

Step 1: Creazione interfaccia Figura

public interface Figura {
    void disegna();
    void calcolaArea();
    void getArea();
}

 

Step 2: Definizione degli Oggetti che implementeranno l’interfaccia

Quadrato.java

public class Quadrato implements Figura {
    private final static int base = 2;
    private static int area = 0;

    @Override
    public void disegna() {
        System.out.println("[QUADRATO] : disegna()");
    }

    @Override
    public void calcolaArea() {
        System.out.println("[QUADRATO] : calcolaArea()::start");
        area = base*base;
        System.out.println("[QUADRATO] : calcolaArea()::end");
    }

    public void getArea() {
        System.out.println("[QUADRATO: area = " + area + " ]");
    }
}

Rettangolo.java

public class Rettangolo implements Figura {

    private final static int base = 2;
    private final static int altezza = 5;
    private static int area = 0;

    @Override
    public void disegna() {
        System.out.println("[RETTANGOLO] : disegna()");
    }

    @Override
    public void calcolaArea() {
        System.out.println("[RETTANGOLO] : calcolaArea()::start");
        area = base * altezza;
        System.out.println("[RETTANGOLO] : calcolaArea()::end");
    }

    public void getArea() {
        System.out.println("[RETTANGOLO: area = " + area + " ]");
    }
}

Cerchio.java

public class Cerchio implements Figura{
    private final static int raggio = 2;
    private final static double piGreco = 3.14;
    private static double area = 0;

    @Override
    public void disegna() {
        System.out.println("[CERCHIO] : disegna()");
    }

    @Override
    public void calcolaArea() {
        System.out.println("[CERCHIO] : calcolaArea()::start");
        area = (raggio*raggio)*piGreco;
        System.out.println("[CERCHIO] : calcolaArea()::end");
    }

    public void getArea() {
        System.out.println("[CERCHIO: area = " + area + " ]");
    }
}

 

Step 3: Creazione della classe astratta per recuperare le varie Factory

public abstract class AbstractFactory {
    abstract Figura getFigura(String figura) ;
}

 

Step 4: Creazione delle Factory che estenderanno AbstractFactory

FiguraFactory.java

public class FiguraFactory extends AbstractFactory {
    @Override
    public Figura getFigura(String figura) {
        if("RETTANGOLO".equalsIgnoreCase(figura)) {
            return new Rettangolo();
        } else if("QUADRATO".equalsIgnoreCase(figura)) {
            return new Quadrato();
        } else {
            return null;
        }
    }
}

GenericFactory.java

public class GenericFactory extends AbstractFactory {
    @Override
    Figura getFigura(String figura) {
        return new Cerchio();
    }
}

Step 5: Creazione del FactoryProducer che avrà il compito di generare la factory opportuna

public class FactoryProducer {
    public static AbstractFactory getFactory(boolean isRettangoloOrQuadrato) {
        if(isRettangoloOrQuadrato) {
            return new FiguraFactory();
        } else {
            return new GenericFactory();
        }
    }
}

Step 6: Creazione main per richiamare le 2 factory

public class Main {
    public static void main(String[] args) {
        AbstractFactory factory1 = FactoryProducer.getFactory(true);
        Figura figura1 = factory1.getFigura("RETTANGOLO");
        figura1.disegna();
        figura1.calcolaArea();
        figura1.getArea();

        Figura figura2 = factory1.getFigura("QUADRATO");
        figura2.disegna();
        figura2.calcolaArea();
        figura2.getArea();

        AbstractFactory factory2 = FactoryProducer.getFactory(false);
        Figura figura3 = factory2.getFigura("CERCHIO");
        figura3.disegna();
        figura3.calcolaArea();
        figura3.getArea();

    }
}

Step 7: Output

[RETTANGOLO] : disegna()
[RETTANGOLO] : calcolaArea()::start
[RETTANGOLO] : calcolaArea()::end
[RETTANGOLO: area = 10 ]
[QUADRATO] : disegna()
[QUADRATO] : calcolaArea()::start
[QUADRATO] : calcolaArea()::end
[QUADRATO: area = 4 ]
[CERCHIO] : disegna()
[CERCHIO] : calcolaArea()::start
[CERCHIO] : calcolaArea()::end
[CERCHIO: area = 12.56 ]

LINK UTILI