Abstract Factory Method

Abstract Factory es un patrón de diseño creacional que nos permite producir familias de objetos relacionados sin especificar sus clases concretas. En este ejemplo el abstract factory va a ser una interfaz cuya función es crear objetos de tipo Gui.

Este va a ser algo así como el padre, pero nosotros podemos crear objetos de tipo Gui para diferentes Sistemas operativos, que vendrían siendo los hijos de la fabrica abstracta gui. Por lo que Gui windows y Gui Linux serían familiares de la fabrica abstracta

Por lo que sería algo así.

Clase abstracta

/**
 * Esta es la Abstract Factory para hacer interfaces gráficas. Es una clase que
 * crea una colección de clases asociadas.
 */
public interface GuiFactory {
    Button createButton();

    Panel createPanel();
}

Como podemos ver tanto si es para windows como si es para linux, se van a crear diferentes tipos de componentes, en este caso Button y Panel, que tambien serán interfaces, pudiendo crear diferentes tipos de botones para cada sistema.

Factory de windows

public class WindowsFactory implements GuiFactory {
    @Override
    public Button createButton() {
        return new WindowsButton();
    }

    @Override
    public Panel createPanel() {
        return new WindowsPanel();
    }
}

public class LinuxFactory implements GuiFactory {
    @Override
    public Button createButton() {
        return new LinuxButton();
    }

    @Override
    public Panel createPanel() {
        return new LinuxPanel();
    }
}

public class LinuxFactory implements GuiFactory {
    @Override
    public Button createButton() {
        return new LinuxButton();
    }

    @Override
    public Panel createPanel() {
        return new LinuxPanel();
    }
}

Luego tenemos una clase selectora, que devuelve una clase factory u otra.

public class GuiFactorySelector {
    public static GuiFactory getFactory(OS os) {
        switch (os) {
            case LINUX:
                return new LinuxFactory();
            case WINDOWS:
                return new WindowsFactory();
            default:
                return null;
        }
    }
}

Vamos a ver ahora los componentes de Gui que se pueden crear. Básicamente tenemos una interfaz principal llamada componente, Y luego tenemos Button y Panel que son un tipo de componente.

Component

/**
 * Todos los componentes de una interfaz gráfica se deben pintar en la pantalla
 */
public interface Component {
    void paint();
}

public interface Panel extends Component {
}

public interface Button extends Component {
}

Para cada Button o Panel hay diferentes implementaciones

public class LinuxButton implements Button {
    @Override
    public void paint() {
        System.out.println("Linux Button");
    }
}

public class LinuxPanel implements Panel {
    @Override
    public void paint() {
        System.out.println("Linux Panel");
    }
}

public class WindowsButton implements Button {
    @Override
    public void paint() {
        System.out.println("Windows Button");
    }
}

public class WindowsPanel implements Panel {
    @Override
    public void paint() {
        System.out.println("Windows Panel");
    }
}

public enum OS {
    WINDOWS, LINUX
}

public class Main {
    public static void main(String[] args) {
        GuiFactory guiFactory = GuiFactorySelector.getFactory(OS.LINUX);

        Button button = guiFactory.createButton(); // Botón que funcionará solo en linux
        button.paint(); // Salida: Linux Button

        Panel panel = guiFactory.createPanel(); // Panel que funcionará solo en linux
        panel.paint(); // Salida: Linux Panel
    }
}