Abstract Factory Pattern

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

/**
 * Abstract Factory interface for creating UI component families.
 * 
 * Each method declares creation of an abstract product type.
 * Concrete factories will return family-specific implementations.
 * 
 * Notice: No family knowledge here. No conditionals.
 * Just a clean contract for creating a family of products.
 */
public interface GUIFactory {
    
    /**
     * Creates a button appropriate for this factory's family.
     * @return A Button implementation specific to the family
     */
    Button createButton();
    
    /**
     * Creates a text field appropriate for this factory's family.
     * @return A TextField implementation specific to the family
     */
    TextField createTextField();
    
    /**
     * Creates a menu appropriate for this factory's family.
     * @return A Menu implementation specific to the family
     */
    Menu createMenu();
    
    /**
     * Creates a checkbox appropriate for this factory's family.
     * @return A Checkbox implementation specific to the family
     */
    Checkbox createCheckbox();
    
    /**
     * Creates a dialog appropriate for this factory's family.
     * @return A Dialog implementation specific to the family
     */
    Dialog createDialog();
    
    /**
     * Creates a scroll bar appropriate for this factory's family.
     * @return A ScrollBar implementation specific to the family
     */
    ScrollBar createScrollBar();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

/**
 * Abstract product: Button
 * 
 * Defines the contract for all button implementations.
 * Concrete buttons (WindowsButton, MacOSButton) must implement this.
 */
public interface Button {
    void render();
    void onClick(Runnable handler);
    void setEnabled(boolean enabled);
    void setText(String text);
    String getText();
}
 
/**
 * Abstract product: TextField
 * 
 * Defines the contract for all text field implementations.
 */
public interface TextField {
    void render();
    String getValue();
    void setValue(String value);
    void setPlaceholder(String placeholder);
    void onTextChange(Consumer<String> handler);
    void setValidation(Predicate<String> validator);
}
 
/**
 * Abstract product: Menu
 * 
 * Defines the contract for all menu implementations.
 */
public interface Menu {
    void render();
    void addItem(String label, Runnable action);
    void addSeparator();
    Menu addSubmenu(String label);
    void setEnabled(boolean enabled);
}
 
/**
 * Abstract product: Checkbox
 * 
 * Defines the contract for all checkbox implementations.
 */
public interface Checkbox {
    void render();
    boolean isChecked();
    void setChecked(boolean checked);
    void setLabel(String label);
    void onToggle(Consumer<Boolean> handler);
}
 
/**
 * Abstract product: Dialog
 * 
 * Defines the contract for all dialog implementations.
 */
public interface Dialog {
    void show();
    void hide();
    void setTitle(String title);
    void setContent(Component content);
    void addButton(Button button);
    DialogResult getResult();
}
 
/**
 * Abstract product: ScrollBar
 * 
 * Defines the contract for all scrollbar implementations.
 */
public interface ScrollBar {
    void render();
    void setRange(int min, int max);
    void setValue(int value);
    int getValue();
    void onScroll(Consumer<Integer> handler);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

/**
 * Concrete Factory: Creates Windows-style UI components.
 * 
 * This factory encapsulates ALL knowledge about Windows UI creation.
 * Adding Windows-specific configuration happens here, not in client code.
 */
public class WindowsFactory implements GUIFactory {
    
    private final WindowsTheme theme;
    private final DpiScaling dpiScaling;
    
    public WindowsFactory() {
        this.theme = WindowsTheme.detectSystemTheme();
        this.dpiScaling = DpiScaling.detectSystemDpi();
    }
    
    @Override
    public Button createButton() {
        WindowsButton button = new WindowsButton();
        button.setTheme(theme);
        button.setDpiScaling(dpiScaling);
        button.setFlatStyle(theme.usesFlatStyle());
        return button;
    }
    
    @Override
    public TextField createTextField() {
        WindowsTextField textField = new WindowsTextField();
        textField.setTheme(theme);
        textField.setDpiScaling(dpiScaling);
        textField.setBorderStyle(WindowsBorderStyle.STANDARD);
        return textField;
    }
    
    @Override
    public Menu createMenu() {
        WindowsMenu menu = new WindowsMenu();
        menu.setTheme(theme);
        menu.setDpiScaling(dpiScaling);
        menu.setKeyboardNavigationEnabled(true); // Windows convention
        return menu;
    }
    
    @Override
    public Checkbox createCheckbox() {
        WindowsCheckbox checkbox = new WindowsCheckbox();
        checkbox.setTheme(theme);
        checkbox.setDpiScaling(dpiScaling);
        checkbox.setCheckmarkStyle(WindowsCheckmarkStyle.STANDARD);
        return checkbox;
    }
    
    @Override
    public Dialog createDialog() {
        WindowsDialog dialog = new WindowsDialog();
        dialog.setTheme(theme);
        dialog.setDpiScaling(dpiScaling);
        dialog.setButtonOrder(ButtonOrder.OK_CANCEL); // Windows convention
        return dialog;
    }
    
    @Override
    public ScrollBar createScrollBar() {
        WindowsScrollBar scrollBar = new WindowsScrollBar();
        scrollBar.setTheme(theme);
        scrollBar.setDpiScaling(dpiScaling);
        scrollBar.setMinThumbSize(theme.getMinimumScrollThumbSize());
        return scrollBar;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

/**
 * Concrete Factory: Creates macOS-style UI components.
 * 
 * This factory encapsulates ALL knowledge about macOS UI creation.
 * macOS conventions (animations, appearance modes) are configured here.
 */
public class MacOSFactory implements GUIFactory {
    
    private final MacOSAppearance appearance;
    private final RetinaScaling retinaScaling;
    
    public MacOSFactory() {
        this.appearance = MacOSAppearance.detectSystemAppearance();
        this.retinaScaling = RetinaScaling.detectDisplayScaling();
    }
    
    @Override
    public Button createButton() {
        MacOSButton button = new MacOSButton();
        button.setAppearance(appearance);
        button.setRetinaScaling(retinaScaling);
        button.setRoundedCorners(true); // macOS signature style
        button.setHasPulseAnimation(true);
        return button;
    }
    
    @Override
    public TextField createTextField() {
        MacOSTextField textField = new MacOSTextField();
        textField.setAppearance(appearance);
        textField.setRetinaScaling(retinaScaling);
        textField.setFocusRingEnabled(true); // macOS focus ring
        return textField;
    }
    
    @Override
    public Menu createMenu() {
        MacOSMenu menu = new MacOSMenu();
        menu.setAppearance(appearance);
        menu.setRetinaScaling(retinaScaling);
        // macOS: menu bar is at top of screen, not in window
        menu.setUsesSystemMenuBar(true);
        return menu;
    }
    
    @Override
    public Checkbox createCheckbox() {
        MacOSCheckbox checkbox = new MacOSCheckbox();
        checkbox.setAppearance(appearance);
        checkbox.setRetinaScaling(retinaScaling);
        checkbox.setAnimated(true); // Smooth check animation
        return checkbox;
    }
    
    @Override
    public Dialog createDialog() {
        MacOSDialog dialog = new MacOSDialog();
        dialog.setAppearance(appearance);
        dialog.setRetinaScaling(retinaScaling);
        dialog.setButtonOrder(ButtonOrder.CANCEL_OK); // macOS convention: opposite!
        dialog.setSheetStyle(true); // Slides from title bar
        return dialog;
    }
    
    @Override
    public ScrollBar createScrollBar() {
        MacOSScrollBar scrollBar = new MacOSScrollBar();
        scrollBar.setAppearance(appearance);
        scrollBar.setRetinaScaling(retinaScaling);
        scrollBar.setOverlayStyle(true); // macOS: scrollbars overlay content
        scrollBar.setAutoHide(true);
        return scrollBar;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

/**
 * Client code that creates UI using Abstract Factory.
 * 
 * CRITICAL: This class has NO knowledge of:
 * - Which platform it's running on
 * - Which concrete factory is in use
 * - Which concrete products are being created
 * 
 * It works exclusively with abstractions.
 */
public class Application {
    
    private final GUIFactory factory;  // Abstract factory - injected!
    
    /**
     * Constructor injection: the factory is provided from outside.
     * The choice of which factory (which family) is made elsewhere.
     */
    public Application(GUIFactory factory) {
        this.factory = factory;
    }
    
    /**
     * Builds a login form using the injected factory.
     * This method works identically on Windows, macOS, or Linux.
     */
    public void buildLoginForm() {
        // Create abstract products - no knowledge of concrete types
        Button submitButton = factory.createButton();
        Button cancelButton = factory.createButton();
        TextField usernameField = factory.createTextField();
        TextField passwordField = factory.createTextField();
        Checkbox rememberMeCheckbox = factory.createCheckbox();
        
        // Configure products using abstract interfaces
        submitButton.setText("Log In");
        cancelButton.setText("Cancel");
        usernameField.setPlaceholder("Username");
        passwordField.setPlaceholder("Password");
        rememberMeCheckbox.setLabel("Remember me");
        
        // Wire up event handlers
        submitButton.onClick(() -> performLogin(
            usernameField.getValue(),
            passwordField.getValue(),
            rememberMeCheckbox.isChecked()
        ));
        cancelButton.onClick(this::closeApplication);
        
        // Layout and render - details abstracted
        renderLoginScreen(submitButton, cancelButton, 
                         usernameField, passwordField, 
                         rememberMeCheckbox);
    }
    
    /**
     * Shows an error dialog using the injected factory.
     */
    public void showError(String title, String message) {
        Dialog errorDialog = factory.createDialog();
        Button okButton = factory.createButton();
        
        errorDialog.setTitle(title);
        okButton.setText("OK");
        okButton.onClick(errorDialog::hide);
        
        errorDialog.addButton(okButton);
        errorDialog.show();
    }
    
    /**
     * Creates the main application menu.
     */
    public Menu createApplicationMenu() {
        Menu mainMenu = factory.createMenu();
        
        Menu fileMenu = mainMenu.addSubmenu("File");
        fileMenu.addItem("New", this::handleNew);
        fileMenu.addItem("Open...", this::handleOpen);
        fileMenu.addItem("Save", this::handleSave);
        fileMenu.addSeparator();
        fileMenu.addItem("Exit", this::closeApplication);
        
        Menu editMenu = mainMenu.addSubmenu("Edit");
        editMenu.addItem("Undo", this::handleUndo);
        editMenu.addItem("Redo", this::handleRedo);
        editMenu.addSeparator();
        editMenu.addItem("Cut", this::handleCut);
        editMenu.addItem("Copy", this::handleCopy);
        editMenu.addItem("Paste", this::handlePaste);
        
        return mainMenu;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

/**
 * Application bootstrap: the ONLY place where family selection occurs.
 * 
 * This is the composition root - where we wire dependencies.
 * All family knowledge is concentrated here.
 */
public class ApplicationBootstrap {
    
    /**
     * Creates the appropriate factory based on the runtime environment.
     * This is the SINGLE point of family selection in the entire application.
     */
    public static GUIFactory createFactory() {
        // Detect platform at runtime
        OperatingSystem os = OperatingSystem.detect();
        
        // Single switch statement - the only place families are mentioned
        return switch (os) {
            case WINDOWS -> new WindowsFactory();
            case MACOS -> new MacOSFactory();
            case LINUX -> new LinuxFactory();
            default -> throw new UnsupportedOperationException(
                "Unsupported operating system: " + os
            );
        };
    }
    
    /**
     * Alternative: configuration-driven factory selection.
     * Useful for testing or forcing a specific look-and-feel.
     */
    public static GUIFactory createFactory(Configuration config) {
        String factoryType = config.get("ui.factory", "auto");
        
        return switch (factoryType) {
            case "windows" -> new WindowsFactory();
            case "macos" -> new MacOSFactory();
            case "linux" -> new LinuxFactory();
            case "auto" -> createFactory(); // Fall back to auto-detect
            default -> throw new ConfigurationException(
                "Unknown factory type: " + factoryType
            );
        };
    }
    
    /**
     * Main entry point: creates and runs the application.
     */
    public static void main(String[] args) {
        // 1. Create the factory (family selection happens HERE)
        GUIFactory factory = createFactory();
        
        // 2. Create the application with the factory
        Application app = new Application(factory);
        
        // 3. Run the application - from here on, no family knowledge
        app.buildLoginForm();
        app.createApplicationMenu();
        app.run();
        
        // The Application class never knows which factory it received.
        // It works identically on all platforms.
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

/**
 * NEW: Concrete Factory for Linux UI components.
 * 
 * Adding this factory requires:
 * 1. This new factory class (implements existing interface)
 * 2. New concrete product classes: LinuxButton, LinuxTextField, etc.
 * 3. One new case in the bootstrap switch statement
 * 
 * NO changes to: GUIFactory interface, Application class,
 * or any other existing code.
 */
public class LinuxFactory implements GUIFactory {
    
    private final GTKTheme theme;
    private final LinuxFontScaling fontScaling;
    
    public LinuxFactory() {
        this.theme = GTKTheme.detectActiveTheme();
        this.fontScaling = LinuxFontScaling.detectSystemScaling();
    }
    
    @Override
    public Button createButton() {
        LinuxButton button = new LinuxButton();
        button.setTheme(theme);
        button.setFontScaling(fontScaling);
        button.setToolkitStyle(detectToolkit()); // GTK, QT, etc.
        return button;
    }
    
    @Override
    public TextField createTextField() {
        LinuxTextField textField = new LinuxTextField();
        textField.setTheme(theme);
        textField.setFontScaling(fontScaling);
        return textField;
    }
    
    @Override
    public Menu createMenu() {
        LinuxMenu menu = new LinuxMenu();
        menu.setTheme(theme);
        menu.setFontScaling(fontScaling);
        // Linux uses various menu systems based on desktop environment
        menu.setMenuBackend(detectMenuBackend());
        return menu;
    }
    
    @Override
    public Checkbox createCheckbox() {
        LinuxCheckbox checkbox = new LinuxCheckbox();
        checkbox.setTheme(theme);
        checkbox.setFontScaling(fontScaling);
        return checkbox;
    }
    
    @Override
    public Dialog createDialog() {
        LinuxDialog dialog = new LinuxDialog();
        dialog.setTheme(theme);
        dialog.setFontScaling(fontScaling);
        dialog.setButtonOrder(ButtonOrder.CANCEL_OK); // GNOME convention
        return dialog;
    }
    
    @Override
    public ScrollBar createScrollBar() {
        LinuxScrollBar scrollBar = new LinuxScrollBar();
        scrollBar.setTheme(theme);
        scrollBar.setFontScaling(fontScaling);
        return scrollBar;
    }
    
    private ToolkitType detectToolkit() {
        // Detect whether running under GTK, QT, or other toolkit
        return GTKTheme.isGTKEnvironment() 
            ? ToolkitType.GTK 
            : ToolkitType.QT;
    }
    
    private MenuBackend detectMenuBackend() {
        // Detect AppIndicator, Unity, GNOME Shell, etc.
        return MenuBackend.detect();
    }
}
 
// Bootstrap update: ONE new case in existing switch
public static GUIFactory createFactory() {
    OperatingSystem os = OperatingSystem.detect();
    
    return switch (os) {
        case WINDOWS -> new WindowsFactory();
        case MACOS -> new MacOSFactory();
        case LINUX -> new LinuxFactory();  // ← Only change to existing code!
        default -> throw new UnsupportedOperationException(
            "Unsupported operating system: " + os
        );
    };
}