Factory Pattern in Java

1. Introduction to Factory Pattern

What is Factory Pattern?

The Factory Pattern is a creational design pattern that provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created.

Why Use Factory Pattern?

Loose coupling between object creation and usage
Centralized object creation logic
Easy to extend with new product types
Promotes Open/Closed Principle
Simplifies complex object creation

Types of Factory Patterns:

Simple Factory (Static Factory)
Factory Method
Abstract Factory

2. Simple Factory Pattern

// Product interface interface Notification { void send(String message); } // Concrete Products class EmailNotification implements Notification { @Override public void send(String message) { System.out.println("Sending Email: " + message); } } class SMSNotification implements Notification { @Override public void send(String message) { System.out.println("Sending SMS: " + message); } } class PushNotification implements Notification { @Override public void send(String message) { System.out.println("Sending Push Notification: " + message); } } // Simple Factory class NotificationFactory { public static Notification createNotification(String type) { switch (type.toLowerCase()) { case "email": return new EmailNotification(); case "sms": return new SMSNotification(); case "push": return new PushNotification(); default: throw new IllegalArgumentException("Unknown notification type: " + type); } } } public class SimpleFactoryExample { public static void main(String[] args) { System.out.println("=== Simple Factory Pattern ==="); // Create notifications using factory Notification email = NotificationFactory.createNotification("email"); Notification sms = NotificationFactory.createNotification("sms"); Notification push = NotificationFactory.createNotification("push"); // Use notifications email.send("Welcome to our service!"); sms.send("Your verification code is 123456"); push.send("You have a new message"); // Demonstrating flexibility System.out.println("\n=== Dynamic Notification Creation ==="); String[] notificationTypes = {"email", "sms", "push", "email"}; for (String type : notificationTypes) { try { Notification notification = NotificationFactory.createNotification(type); notification.send("Batch message via " + type.toUpperCase()); } catch (IllegalArgumentException e) { System.err.println("Error: " + e.getMessage()); } } } }

3. Complete Code Examples

Example 1: Factory Method Pattern

// Product interface interface Document { void open(); void save(); void close(); String getType(); } // Concrete Products class WordDocument implements Document { @Override public void open() { System.out.println("Opening Word document..."); } @Override public void save() { System.out.println("Saving Word document..."); } @Override public void close() { System.out.println("Closing Word document..."); } @Override public String getType() { return "Word Document"; } } class PDFDocument implements Document { @Override public void open() { System.out.println("Opening PDF document..."); } @Override public void save() { System.out.println("Saving PDF document..."); } @Override public void close() { System.out.println("Closing PDF document..."); } @Override public String getType() { return "PDF Document"; } } class ExcelDocument implements Document { @Override public void open() { System.out.println("Opening Excel document..."); } @Override public void save() { System.out.println("Saving Excel document..."); } @Override public void close() { System.out.println("Closing Excel document..."); } @Override public String getType() { return "Excel Document"; } } // Creator abstract class abstract class DocumentCreator { // Factory method - to be implemented by subclasses public abstract Document createDocument(); // Some business logic that uses the factory method public void processDocument() { Document doc = createDocument(); System.out.println("Processing " + doc.getType()); doc.open(); doc.save(); doc.close(); System.out.println(); } } // Concrete Creators class WordDocumentCreator extends DocumentCreator { @Override public Document createDocument() { return new WordDocument(); } } class PDFDocumentCreator extends DocumentCreator { @Override public Document createDocument() { return new PDFDocument(); } } class ExcelDocumentCreator extends DocumentCreator { @Override public Document createDocument() { return new ExcelDocument(); } } public class FactoryMethodExample { public static void main(String[] args) { System.out.println("=== Factory Method Pattern ==="); // Using different creators DocumentCreator[] creators = { new WordDocumentCreator(), new PDFDocumentCreator(), new ExcelDocumentCreator() }; // Process documents using factory method for (DocumentCreator creator : creators) { creator.processDocument(); } // Demonstrate creating documents directly System.out.println("=== Direct Document Creation ==="); DocumentCreator wordCreator = new WordDocumentCreator(); Document wordDoc = wordCreator.createDocument(); wordDoc.open(); wordDoc.save(); wordDoc.close(); // Factory method with parameters System.out.println("\n=== Parameterized Factory ==="); Document parameterizedDoc = createDocumentByType("pdf"); if (parameterizedDoc != null) { parameterizedDoc.open(); parameterizedDoc.save(); parameterizedDoc.close(); } } // Utility method demonstrating parameterized factory public static Document createDocumentByType(String type) { switch (type.toLowerCase()) { case "word": return new WordDocumentCreator().createDocument(); case "pdf": return new PDFDocumentCreator().createDocument(); case "excel": return new ExcelDocumentCreator().createDocument(); default: System.err.println("Unknown document type: " + type); return null; } } }

Example 2: Abstract Factory Pattern

// Abstract Products interface Button { void render(); void onClick(); } interface Checkbox { void render(); boolean isChecked(); } interface TextField { void render(); void setText(String text); String getText(); } // Concrete Products for Windows class WindowsButton implements Button { @Override public void render() { System.out.println("Rendering Windows-style button"); } @Override public void onClick() { System.out.println("Windows button clicked!"); } } class WindowsCheckbox implements Checkbox { private boolean checked = false; @Override public void render() { System.out.println("Rendering Windows-style checkbox"); } @Override public boolean isChecked() { return checked; } public void setChecked(boolean checked) { this.checked = checked; System.out.println("Windows checkbox " + (checked ? "checked" : "unchecked")); } } class WindowsTextField implements TextField { private String text = ""; @Override public void render() { System.out.println("Rendering Windows-style text field"); } @Override public void setText(String text) { this.text = text; System.out.println("Windows text field set to: " + text); } @Override public String getText() { return text; } } // Concrete Products for Mac class MacButton implements Button { @Override public void render() { System.out.println("Rendering Mac-style button"); } @Override public void onClick() { System.out.println("Mac button clicked!"); } } class MacCheckbox implements Checkbox { private boolean checked = false; @Override public void render() { System.out.println("Rendering Mac-style checkbox"); } @Override public boolean isChecked() { return checked; } public void setChecked(boolean checked) { this.checked = checked; System.out.println("Mac checkbox " + (checked ? "checked" : "unchecked")); } } class MacTextField implements TextField { private String text = ""; @Override public void render() { System.out.println("Rendering Mac-style text field"); } @Override public void setText(String text) { this.text = text; System.out.println("Mac text field set to: " + text); } @Override public String getText() { return text; } } // Concrete Products for Linux class LinuxButton implements Button { @Override public void render() { System.out.println("Rendering Linux-style button"); } @Override public void onClick() { System.out.println("Linux button clicked!"); } } class LinuxCheckbox implements Checkbox { private boolean checked = false; @Override public void render() { System.out.println("Rendering Linux-style checkbox"); } @Override public boolean isChecked() { return checked; } public void setChecked(boolean checked) { this.checked = checked; System.out.println("Linux checkbox " + (checked ? "checked" : "unchecked")); } } class LinuxTextField implements TextField { private String text = ""; @Override public void render() { System.out.println("Rendering Linux-style text field"); } @Override public void setText(String text) { this.text = text; System.out.println("Linux text field set to: " + text); } @Override public String getText() { return text; } } // Abstract Factory interface GUIFactory { Button createButton(); Checkbox createCheckbox(); TextField createTextField(); } // Concrete Factories class WindowsFactory implements GUIFactory { @Override public Button createButton() { return new WindowsButton(); } @Override public Checkbox createCheckbox() { return new WindowsCheckbox(); } @Override public TextField createTextField() { return new WindowsTextField(); } } class MacFactory implements GUIFactory { @Override public Button createButton() { return new MacButton(); } @Override public Checkbox createCheckbox() { return new MacCheckbox(); } @Override public TextField createTextField() { return new MacTextField(); } } class LinuxFactory implements GUIFactory { @Override public Button createButton() { return new LinuxButton(); } @Override public Checkbox createCheckbox() { return new LinuxCheckbox(); } @Override public TextField createTextField() { return new LinuxTextField(); } } // Factory provider class GUIFactoryProvider { public static GUIFactory getFactory(String osType) { switch (osType.toLowerCase()) { case "windows": return new WindowsFactory(); case "mac": return new MacFactory(); case "linux": return new LinuxFactory(); default: throw new IllegalArgumentException("Unknown OS type: " + osType); } } } // Client code class Application { private Button button; private Checkbox checkbox; private TextField textField; public Application(GUIFactory factory) { this.button = factory.createButton(); this.checkbox = factory.createCheckbox(); this.textField = factory.createTextField(); } public void renderUI() { System.out.println("\n=== Rendering UI ==="); button.render(); checkbox.render(); textField.render(); } public void simulateUserInteraction() { System.out.println("\n=== User Interaction ==="); button.onClick(); // Cast to specific type to use platform-specific methods if (checkbox instanceof WindowsCheckbox) { ((WindowsCheckbox) checkbox).setChecked(true); } else if (checkbox instanceof MacCheckbox) { ((MacCheckbox) checkbox).setChecked(true); } else if (checkbox instanceof LinuxCheckbox) { ((LinuxCheckbox) checkbox).setChecked(true); } textField.setText("Hello, World!"); System.out.println("Text field contains: " + textField.getText()); } } public class AbstractFactoryExample { public static void main(String[] args) { System.out.println("=== Abstract Factory Pattern ==="); // Test with different operating systems String[] operatingSystems = {"windows", "mac", "linux"}; for (String os : operatingSystems) { System.out.println("\n" + "=".repeat(50)); System.out.println("Creating application for: " + os.toUpperCase()); System.out.println("=".repeat(50)); try { GUIFactory factory = GUIFactoryProvider.getFactory(os); Application app = new Application(factory); app.renderUI(); app.simulateUserInteraction(); } catch (IllegalArgumentException e) { System.err.println("Error: " + e.getMessage()); } } // Demonstrate factory switching at runtime System.out.println("\n=== Runtime Factory Switching ==="); demonstrateRuntimeSwitching(); } public static void demonstrateRuntimeSwitching() { // Simulate detecting OS at runtime String detectedOS = System.getProperty("os.name").toLowerCase(); String factoryType; if (detectedOS.contains("win")) { factoryType = "windows"; } else if (detectedOS.contains("mac")) { factoryType = "mac"; } else { factoryType = "linux"; } System.out.println("Detected OS: " + detectedOS); System.out.println("Using factory: " + factoryType); GUIFactory factory = GUIFactoryProvider.getFactory(factoryType); Application app = new Application(factory); app.renderUI(); } }

Example 3: Real-World Database Connection Factory

import java.sql.*; import java.util.*; // Product interface interface DatabaseConnection { Connection getConnection() throws SQLException; void close() throws SQLException; boolean testConnection() throws SQLException; String getDatabaseType(); } // Concrete Products class MySQLConnection implements DatabaseConnection { private Connection connection; private final String url; private final String username; private final String password; public MySQLConnection(String host, int port, String database, String username, String password) { this.url = String.format("jdbc:mysql://%s:%d/%s", host, port, database); this.username = username; this.password = password; } @Override public Connection getConnection() throws SQLException { if (connection == null || connection.isClosed()) { connection = DriverManager.getConnection(url, username, password); } return connection; } @Override public void close() throws SQLException { if (connection != null && !connection.isClosed()) { connection.close(); } } @Override public boolean testConnection() throws SQLException { try (Connection conn = getConnection()) { return conn.isValid(2); // 2 second timeout } } @Override public String getDatabaseType() { return "MySQL"; } } class PostgreSQLConnection implements DatabaseConnection { private Connection connection; private final String url; private final String username; private final String password; public PostgreSQLConnection(String host, int port, String database, String username, String password) { this.url = String.format("jdbc:postgresql://%s:%d/%s", host, port, database); this.username = username; this.password = password; } @Override public Connection getConnection() throws SQLException { if (connection == null || connection.isClosed()) { connection = DriverManager.getConnection(url, username, password); } return connection; } @Override public void close() throws SQLException { if (connection != null && !connection.isClosed()) { connection.close(); } } @Override public boolean testConnection() throws SQLException { try (Connection conn = getConnection()) { return conn.isValid(2); } } @Override public String getDatabaseType() { return "PostgreSQL"; } } class OracleConnection implements DatabaseConnection { private Connection connection; private final String url; private final String username; private final String password; public OracleConnection(String host, int port, String service, String username, String password) { this.url = String.format("jdbc:oracle:thin:@%s:%d:%s", host, port, service); this.username = username; this.password = password; } @Override public Connection getConnection() throws SQLException { if (connection == null || connection.isClosed()) { connection = DriverManager.getConnection(url, username, password); } return connection; } @Override public void close() throws SQLException { if (connection != null && !connection.isClosed()) { connection.close(); } } @Override public boolean testConnection() throws SQLException { try (Connection conn = getConnection()) { return conn.isValid(2); } } @Override public String getDatabaseType() { return "Oracle"; } } // Connection Configuration class ConnectionConfig { private final String host; private final int port; private final String database; private final String username; private final String password; private final Map<String, String> properties; public ConnectionConfig(String host, int port, String database, String username, String password) { this.host = host; this.port = port; this.database = database; this.username = username; this.password = password; this.properties = new HashMap<>(); } public ConnectionConfig addProperty(String key, String value) { this.properties.put(key, value); return this; } // Getters public String getHost() { return host; } public int getPort() { return port; } public String getDatabase() { return database; } public String getUsername() { return username; } public String getPassword() { return password; } public Map<String, String> getProperties() { return new HashMap<>(properties); } } // Abstract Factory interface ConnectionFactory { DatabaseConnection createConnection(ConnectionConfig config); String getSupportedDatabase(); } // Concrete Factories class MySQLConnectionFactory implements ConnectionFactory { @Override public DatabaseConnection createConnection(ConnectionConfig config) { return new MySQLConnection( config.getHost(), config.getPort(), config.getDatabase(), config.getUsername(), config.getPassword() ); } @Override public String getSupportedDatabase() { return "MySQL"; } } class PostgreSQLConnectionFactory implements ConnectionFactory { @Override public DatabaseConnection createConnection(ConnectionConfig config) { return new PostgreSQLConnection( config.getHost(), config.getPort(), config.getDatabase(), config.getUsername(), config.getPassword() ); } @Override public String getSupportedDatabase() { return "PostgreSQL"; } } class OracleConnectionFactory implements ConnectionFactory { @Override public DatabaseConnection createConnection(ConnectionConfig config) { return new OracleConnection( config.getHost(), config.getPort(), config.getDatabase(), // Used as service name for Oracle config.getUsername(), config.getPassword() ); } @Override public String getSupportedDatabase() { return "Oracle"; } } // Factory Provider with Registry class ConnectionFactoryRegistry { private static final Map<String, ConnectionFactory> factories = new HashMap<>(); static { registerFactory("mysql", new MySQLConnectionFactory()); registerFactory("postgresql", new PostgreSQLConnectionFactory()); registerFactory("oracle", new OracleConnectionFactory()); } public static void registerFactory(String databaseType, ConnectionFactory factory) { factories.put(databaseType.toLowerCase(), factory); } public static ConnectionFactory getFactory(String databaseType) { ConnectionFactory factory = factories.get(databaseType.toLowerCase()); if (factory == null) { throw new IllegalArgumentException("Unsupported database type: " + databaseType); } return factory; } public static Set<String> getSupportedDatabases() { return new HashSet<>(factories.keySet()); } } // Connection Pool using Factory class ConnectionPool { private final ConnectionFactory factory; private final ConnectionConfig config; private final List<DatabaseConnection> availableConnections; private final List<DatabaseConnection> usedConnections; private final int maxPoolSize; public ConnectionPool(String databaseType, ConnectionConfig config, int maxPoolSize) { this.factory = ConnectionFactoryRegistry.getFactory(databaseType); this.config = config; this.maxPoolSize = maxPoolSize; this.availableConnections = new ArrayList<>(); this.usedConnections = new ArrayList<>(); initializePool(); } private void initializePool() { for (int i = 0; i < Math.min(3, maxPoolSize); i++) { // Start with 3 connections availableConnections.add(factory.createConnection(config)); } } public DatabaseConnection getConnection() throws SQLException { if (availableConnections.isEmpty()) { if (usedConnections.size() < maxPoolSize) { availableConnections.add(factory.createConnection(config)); } else { throw new SQLException("Connection pool exhausted"); } } DatabaseConnection connection = availableConnections.remove(availableConnections.size() - 1); if (!connection.testConnection()) { // Create new connection if test fails connection = factory.createConnection(config); } usedConnections.add(connection); return connection; } public void releaseConnection(DatabaseConnection connection) { usedConnections.remove(connection); availableConnections.add(connection); } public void closeAllConnections() throws SQLException { for (DatabaseConnection conn : availableConnections) { conn.close(); } for (DatabaseConnection conn : usedConnections) { conn.close(); } availableConnections.clear(); usedConnections.clear(); } public int getAvailableCount() { return availableConnections.size(); } public int getUsedCount() { return usedConnections.size(); } } public class DatabaseConnectionFactoryExample { public static void main(String[] args) { System.out.println("=== Database Connection Factory Pattern ==="); // Display supported databases System.out.println("Supported databases: " + ConnectionFactoryRegistry.getSupportedDatabases()); // Test different database connections testDatabaseConnections(); // Test connection pool testConnectionPool(); // Demonstrate dynamic factory registration demonstrateDynamicRegistration(); } public static void testDatabaseConnections() { System.out.println("\n=== Testing Database Connections ==="); // Configuration for different databases ConnectionConfig mysqlConfig = new ConnectionConfig("localhost", 3306, "testdb", "user", "password"); ConnectionConfig postgresConfig = new ConnectionConfig("localhost", 5432, "testdb", "user", "password"); ConnectionConfig oracleConfig = new ConnectionConfig("localhost", 1521, "XE", "user", "password"); String[] databases = {"mysql", "postgresql", "oracle"}; ConnectionConfig[] configs = {mysqlConfig, postgresConfig, oracleConfig}; for (int i = 0; i < databases.length; i++) { String dbType = databases[i]; ConnectionConfig config = configs[i]; System.out.println("\nTesting " + dbType.toUpperCase() + " connection:"); try { ConnectionFactory factory = ConnectionFactoryRegistry.getFactory(dbType); DatabaseConnection connection = factory.createConnection(config); System.out.println("Database type: " + connection.getDatabaseType()); System.out.println("Connection test: " + (connection.testConnection() ? "PASS" : "FAIL")); // Try to get actual connection (will fail without real database, but demonstrates pattern) try { Connection conn = connection.getConnection(); System.out.println("Connection obtained successfully"); connection.close(); } catch (SQLException e) { System.out.println("Expected connection failure (no real database): " + e.getMessage()); } } catch (Exception e) { System.err.println("Error with " + dbType + ": " + e.getMessage()); } } } public static void testConnectionPool() { System.out.println("\n=== Testing Connection Pool ==="); ConnectionConfig config = new ConnectionConfig("localhost", 3306, "testdb", "user", "password"); try (ConnectionPool pool = new ConnectionPool("mysql", config, 5)) { System.out.println("Pool created. Available connections: " + pool.getAvailableCount()); // Simulate getting connections List<DatabaseConnection> connections = new ArrayList<>(); for (int i = 0; i < 3; i++) { try { DatabaseConnection conn = pool.getConnection(); connections.add(conn); System.out.printf("Got connection %d. Available: %d, Used: %d%n", i + 1, pool.getAvailableCount(), pool.getUsedCount()); } catch (SQLException e) { System.err.println("Failed to get connection: " + e.getMessage()); } } // Release connections for (DatabaseConnection conn : connections) { pool.releaseConnection(conn); System.out.printf("Released connection. Available: %d, Used: %d%n", pool.getAvailableCount(), pool.getUsedCount()); } } catch (Exception e) { System.err.println("Pool error: " + e.getMessage()); } } public static void demonstrateDynamicRegistration() { System.out.println("\n=== Dynamic Factory Registration ==="); // Create a custom database factory ConnectionFactory sqliteFactory = new ConnectionFactory() { @Override public DatabaseConnection createConnection(ConnectionConfig config) { return new DatabaseConnection() { @Override public Connection getConnection() throws SQLException { throw new SQLException("SQLite not implemented in this example"); } @Override public void close() throws SQLException { // No-op for demo } @Override public boolean testConnection() throws SQLException { return true; // Always return true for demo } @Override public String getDatabaseType() { return "SQLite"; } }; } @Override public String getSupportedDatabase() { return "sqlite"; } }; // Register the custom factory ConnectionFactoryRegistry.registerFactory("sqlite", sqliteFactory); System.out.println("Registered custom factory for: sqlite"); System.out.println("Now supported databases: " + ConnectionFactoryRegistry.getSupportedDatabases()); // Test the custom factory try { ConnectionFactory factory = ConnectionFactoryRegistry.getFactory("sqlite"); DatabaseConnection connection = factory.createConnection( new ConnectionConfig("", 0, "test.db", "", "") ); System.out.println("Custom connection type: " + connection.getDatabaseType()); System.out.println("Custom connection test: " + (connection.testConnection() ? "PASS" : "FAIL")); } catch (Exception e) { System.err.println("Custom factory test failed: " + e.getMessage()); } } }

Example 4: Payment Processing System

import java.util.*; // Payment method interface interface PaymentMethod { boolean processPayment(double amount, String currency); boolean refund(double amount, String currency); String getPaymentMethodName(); Map<String, String> getPaymentDetails(); } // Concrete Payment Methods class CreditCardPayment implements PaymentMethod { private String cardNumber; private String cardHolder; private String expiryDate; private String cvv; public CreditCardPayment(String cardNumber, String cardHolder, String expiryDate, String cvv) { this.cardNumber = cardNumber; this.cardHolder = cardHolder; this.expiryDate = expiryDate; this.cvv = cvv; } @Override public boolean processPayment(double amount, String currency) { System.out.printf("Processing credit card payment: %.2f %s%n", amount, currency); System.out.printf("Card: %s, Holder: %s%n", maskCardNumber(cardNumber), cardHolder); // Simulate payment processing boolean success = Math.random() > 0.1; // 90% success rate for demo System.out.println("Payment " + (success ? "approved" : "declined")); return success; } @Override public boolean refund(double amount, String currency) { System.out.printf("Processing credit card refund: %.2f %s%n", amount, currency); System.out.printf("Card: %s%n", maskCardNumber(cardNumber)); // Simulate refund processing boolean success = Math.random() > 0.05; // 95% success rate for demo System.out.println("Refund " + (success ? "processed" : "failed")); return success; } @Override public String getPaymentMethodName() { return "Credit Card"; } @Override public Map<String, String> getPaymentDetails() { Map<String, String> details = new HashMap<>(); details.put("cardNumber", maskCardNumber(cardNumber)); details.put("cardHolder", cardHolder); details.put("expiryDate", expiryDate); details.put("type", "VISA"); // Simplified return details; } private String maskCardNumber(String cardNumber) { if (cardNumber.length() <= 4) return cardNumber; return "****-****-****-" + cardNumber.substring(cardNumber.length() - 4); } } class PayPalPayment implements PaymentMethod { private String email; private String transactionId; public PayPalPayment(String email) { this.email = email; } @Override public boolean processPayment(double amount, String currency) { System.out.printf("Processing PayPal payment: %.2f %s%n", amount, currency); System.out.printf("Email: %s%n", email); // Simulate PayPal processing boolean success = Math.random() > 0.05; // 95% success rate for demo if (success) { this.transactionId = "PP" + System.currentTimeMillis(); System.out.println("Payment approved. Transaction ID: " + transactionId); } else { System.out.println("Payment declined"); } return success; } @Override public boolean refund(double amount, String currency) { System.out.printf("Processing PayPal refund: %.2f %s%n", amount, currency); System.out.printf("Transaction ID: %s%n", transactionId); // Simulate refund processing boolean success = Math.random() > 0.02; // 98% success rate for demo System.out.println("Refund " + (success ? "processed" : "failed")); return success; } @Override public String getPaymentMethodName() { return "PayPal"; } @Override public Map<String, String> getPaymentDetails() { Map<String, String> details = new HashMap<>(); details.put("email", email); details.put("transactionId", transactionId != null ? transactionId : "N/A"); return details; } } class BankTransferPayment implements PaymentMethod { private String accountNumber; private String routingNumber; private String accountHolder; public BankTransferPayment(String accountNumber, String routingNumber, String accountHolder) { this.accountNumber = accountNumber; this.routingNumber = routingNumber; this.accountHolder = accountHolder; } @Override public boolean processPayment(double amount, String currency) { System.out.printf("Processing bank transfer: %.2f %s%n", amount, currency); System.out.printf("Account: %s, Holder: %s%n", maskAccountNumber(accountNumber), accountHolder); // Bank transfers are always "successful" immediately in this simulation System.out.println("Transfer initiated successfully"); return true; } @Override public boolean refund(double amount, String currency) { System.out.printf("Processing bank transfer refund: %.2f %s%n", amount, currency); System.out.println("Bank transfer refunds require manual processing"); return false; // Bank transfers typically don't support instant refunds } @Override public String getPaymentMethodName() { return "Bank Transfer"; } @Override public Map<String, String> getPaymentDetails() { Map<String, String> details = new HashMap<>(); details.put("accountNumber", maskAccountNumber(accountNumber)); details.put("routingNumber", routingNumber); details.put("accountHolder", accountHolder); return details; } private String maskAccountNumber(String accountNumber) { if (accountNumber.length() <= 4) return accountNumber; return "***" + accountNumber.substring(accountNumber.length() - 4); } } class CryptocurrencyPayment implements PaymentMethod { private String walletAddress; private String cryptocurrency; public CryptocurrencyPayment(String walletAddress, String cryptocurrency) { this.walletAddress = walletAddress; this.cryptocurrency = cryptocurrency; } @Override public boolean processPayment(double amount, String currency) { System.out.printf("Processing %s payment: %.2f %s%n", cryptocurrency, amount, currency); System.out.printf("Wallet: %s%n", maskWalletAddress(walletAddress)); // Simulate crypto transaction boolean success = Math.random() > 0.2; // 80% success rate for demo if (success) { System.out.println("Transaction confirmed on blockchain"); } else { System.out.println("Transaction failed or pending"); } return success; } @Override public boolean refund(double amount, String currency) { System.out.printf("Processing %s refund: %.2f %s%n", cryptocurrency, amount, currency); System.out.println("Cryptocurrency refunds require new transaction"); // In crypto, refunds are just new transactions return processPayment(amount, currency); } @Override public String getPaymentMethodName() { return cryptocurrency + " (Crypto)"; } @Override public Map<String, String> getPaymentDetails() { Map<String, String> details = new HashMap<>(); details.put("walletAddress", maskWalletAddress(walletAddress)); details.put("cryptocurrency", cryptocurrency); return details; } private String maskWalletAddress(String walletAddress) { if (walletAddress.length() <= 8) return walletAddress; return walletAddress.substring(0, 4) + "..." + walletAddress.substring(walletAddress.length() - 4); } } // Payment Factory class PaymentFactory { public static PaymentMethod createPaymentMethod(String type, Map<String, String> parameters) { switch (type.toLowerCase()) { case "creditcard": return new CreditCardPayment( parameters.get("cardNumber"), parameters.get("cardHolder"), parameters.get("expiryDate"), parameters.get("cvv") ); case "paypal": return new PayPalPayment(parameters.get("email")); case "banktransfer": return new BankTransferPayment( parameters.get("accountNumber"), parameters.get("routingNumber"), parameters.get("accountHolder") ); case "crypto": return new CryptocurrencyPayment( parameters.get("walletAddress"), parameters.get("cryptocurrency") ); default: throw new IllegalArgumentException("Unsupported payment method: " + type); } } } // Payment Processor class PaymentProcessor { private PaymentMethod paymentMethod; public void setPaymentMethod(PaymentMethod paymentMethod) { this.paymentMethod = paymentMethod; } public boolean processPayment(double amount, String currency) { if (paymentMethod == null) { throw new IllegalStateException("Payment method not set"); } System.out.println("\n" + "=".repeat(50)); System.out.println("PROCESSING PAYMENT"); System.out.println("=".repeat(50)); boolean success = paymentMethod.processPayment(amount, currency); if (success) { System.out.println("✅ Payment completed successfully"); } else { System.out.println("❌ Payment failed"); } return success; } public boolean processRefund(double amount, String currency) { if (paymentMethod == null) { throw new IllegalStateException("Payment method not set"); } System.out.println("\n" + "=".repeat(50)); System.out.println("PROCESSING REFUND"); System.out.println("=".repeat(50)); boolean success = paymentMethod.refund(amount, currency); if (success) { System.out.println("✅ Refund completed successfully"); } else { System.out.println("❌ Refund failed or requires manual processing"); } return success; } public void displayPaymentDetails() { if (paymentMethod != null) { System.out.println("\nPayment Method: " + paymentMethod.getPaymentMethodName()); Map<String, String> details = paymentMethod.getPaymentDetails(); details.forEach((key, value) -> System.out.printf(" %s: %s%n", key, value)); } } } public class PaymentProcessingExample { public static void main(String[] args) { System.out.println("=== Payment Processing Factory Pattern ==="); PaymentProcessor processor = new PaymentProcessor(); // Test different payment methods testCreditCardPayment(processor); testPayPalPayment(processor); testBankTransferPayment(processor); testCryptocurrencyPayment(processor); // Demonstrate dynamic payment method switching demonstrateDynamicSwitching(processor); } public static void testCreditCardPayment(PaymentProcessor processor) { System.out.println("\n" + "=".repeat(60)); System.out.println("TESTING CREDIT CARD PAYMENT"); System.out.println("=".repeat(60)); Map<String, String> params = new HashMap<>(); params.put("cardNumber", "4111111111111111"); params.put("cardHolder", "John Doe"); params.put("expiryDate", "12/25"); params.put("cvv", "123"); PaymentMethod creditCard = PaymentFactory.createPaymentMethod("creditcard", params); processor.setPaymentMethod(creditCard); processor.displayPaymentDetails(); processor.processPayment(99.99, "USD"); processor.processRefund(25.00, "USD"); } public static void testPayPalPayment(PaymentProcessor processor) { System.out.println("\n" + "=".repeat(60)); System.out.println("TESTING PAYPAL PAYMENT"); System.out.println("=".repeat(60)); Map<String, String> params = new HashMap<>(); params.put("email", "[email protected]"); PaymentMethod paypal = PaymentFactory.createPaymentMethod("paypal", params); processor.setPaymentMethod(paypal); processor.displayPaymentDetails(); processor.processPayment(49.99, "EUR"); processor.processRefund(49.99, "EUR"); } public static void testBankTransferPayment(PaymentProcessor processor) { System.out.println("\n" + "=".repeat(60)); System.out.println("TESTING BANK TRANSFER PAYMENT"); System.out.println("=".repeat(60)); Map<String, String> params = new HashMap<>(); params.put("accountNumber", "1234567890"); params.put("routingNumber", "021000021"); params.put("accountHolder", "John Doe"); PaymentMethod bankTransfer = PaymentFactory.createPaymentMethod("banktransfer", params); processor.setPaymentMethod(bankTransfer); processor.displayPaymentDetails(); processor.processPayment(199.99, "USD"); processor.processRefund(199.99, "USD"); } public static void testCryptocurrencyPayment(PaymentProcessor processor) { System.out.println("\n" + "=".repeat(60)); System.out.println("TESTING CRYPTOCURRENCY PAYMENT"); System.out.println("=".repeat(60)); Map<String, String> params = new HashMap<>(); params.put("walletAddress", "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"); params.put("cryptocurrency", "Bitcoin"); PaymentMethod crypto = PaymentFactory.createPaymentMethod("crypto", params); processor.setPaymentMethod(crypto); processor.displayPaymentDetails(); processor.processPayment(0.005, "BTC"); processor.processRefund(0.001, "BTC"); } public static void demonstrateDynamicSwitching(PaymentProcessor processor) { System.out.println("\n" + "=".repeat(60)); System.out.println("DYNAMIC PAYMENT METHOD SWITCHING"); System.out.println("=".repeat(60)); // Simulate user selecting different payment methods String[] paymentTypes = {"creditcard", "paypal", "crypto"}; double[] amounts = {75.50, 120.00, 0.0025}; String[] currencies = {"USD", "EUR", "BTC"}; for (int i = 0; i < paymentTypes.length; i++) { System.out.printf("\n--- Transaction %d: %s ---%n", i + 1, paymentTypes[i].toUpperCase()); Map<String, String> params = new HashMap<>(); switch (paymentTypes[i]) { case "creditcard": params.put("cardNumber", "5555555555554444"); params.put("cardHolder", "Jane Smith"); params.put("expiryDate", "06/26"); params.put("cvv", "456"); break; case "paypal": params.put("email", "[email protected]"); break; case "crypto": params.put("walletAddress", "0x742d35Cc6634C0532925a3b8D"); params.put("cryptocurrency", "Ethereum"); break; } try { PaymentMethod method = PaymentFactory.createPaymentMethod(paymentTypes[i], params); processor.setPaymentMethod(method); processor.displayPaymentDetails(); processor.processPayment(amounts[i], currencies[i]); } catch (Exception e) { System.err.println("Error: " + e.getMessage()); } } } }

Example 5: Advanced Factory with Configuration and Caching

import java.util.*; import java.util.concurrent.*; // Product interface interface Cache { void put(String key, Object value); Object get(String key); void remove(String key); void clear(); int size(); String getCacheType(); Map<String, Object> getStats(); } // Concrete Products class MemoryCache implements Cache { private final Map<String, Object> storage = new ConcurrentHashMap<>(); private final Map<String, Long> accessTimes = new ConcurrentHashMap<>(); private final int maxSize; private int hitCount = 0; private int missCount = 0; public MemoryCache(int maxSize) { this.maxSize = maxSize; } @Override public void put(String key, Object value) { if (storage.size() >= maxSize) { // Simple LRU eviction evictLeastRecentlyUsed(); } storage.put(key, value); accessTimes.put(key, System.currentTimeMillis()); } @Override public Object get(String key) { Object value = storage.get(key); if (value != null) { accessTimes.put(key, System.currentTimeMillis()); hitCount++; } else { missCount++; } return value; } @Override public void remove(String key) { storage.remove(key); accessTimes.remove(key); } @Override public void clear() { storage.clear(); accessTimes.clear(); hitCount = 0; missCount = 0; } @Override public int size() { return storage.size(); } @Override public String getCacheType() { return "Memory Cache"; } @Override public Map<String, Object> getStats() { Map<String, Object> stats = new HashMap<>(); stats.put("size", size()); stats.put("maxSize", maxSize); stats.put("hitCount", hitCount); stats.put("missCount", missCount); stats.put("hitRate", hitCount + missCount > 0 ? (double) hitCount / (hitCount + missCount) : 0.0); return stats; } private void evictLeastRecentlyUsed() { String lruKey = null; long oldestTime = Long.MAX_VALUE; for (Map.Entry<String, Long> entry : accessTimes.entrySet()) { if (entry.getValue() < oldestTime) { oldestTime = entry.getValue(); lruKey = entry.getKey(); } } if (lruKey != null) { remove(lruKey); } } } class DiskCache implements Cache { private final Map<String, Object> storage = new ConcurrentHashMap<>(); private final String cacheDir; private int hitCount = 0; private int missCount = 0; public DiskCache(String cacheDir) { this.cacheDir = cacheDir; // In real implementation, this would interact with actual disk storage } @Override public void put(String key, Object value) { storage.put(key, value); // Simulate disk write System.out.println("Writing to disk: " + key); } @Override public Object get(String key) { Object value = storage.get(key); if (value != null) { hitCount++; } else { missCount++; } return value; } @Override public void remove(String key) { storage.remove(key); // Simulate disk removal System.out.println("Removing from disk: " + key); } @Override public void clear() { storage.clear(); hitCount = 0; missCount = 0; System.out.println("Cleared disk cache"); } @Override public int size() { return storage.size(); } @Override public String getCacheType() { return "Disk Cache"; } @Override public Map<String, Object> getStats() { Map<String, Object> stats = new HashMap<>(); stats.put("size", size()); stats.put("cacheDir", cacheDir); stats.put("hitCount", hitCount); stats.put("missCount", missCount); stats.put("hitRate", hitCount + missCount > 0 ? (double) hitCount / (hitCount + missCount) : 0.0); return stats; } } class RedisCache implements Cache { private final Map<String, Object> storage = new ConcurrentHashMap<>(); private final String redisUrl; private final int redisPort; private int hitCount = 0; private int missCount = 0; public RedisCache(String redisUrl, int redisPort) { this.redisUrl = redisUrl; this.redisPort = redisPort; // In real implementation, this would connect to Redis } @Override public void put(String key, Object value) { storage.put(key, value); // Simulate Redis SET operation System.out.println("Redis SET: " + key); } @Override public Object get(String key) { Object value = storage.get(key); if (value != null) { hitCount++; } else { missCount++; } return value; } @Override public void remove(String key) { storage.remove(key); // Simulate Redis DEL operation System.out.println("Redis DEL: " + key); } @Override public void clear() { storage.clear(); hitCount = 0; missCount = 0; System.out.println("Redis FLUSHDB"); } @Override public int size() { return storage.size(); } @Override public String getCacheType() { return "Redis Cache"; } @Override public Map<String, Object> getStats() { Map<String, Object> stats = new HashMap<>(); stats.put("size", size()); stats.put("redisUrl", redisUrl); stats.put("redisPort", redisPort); stats.put("hitCount", hitCount); stats.put("missCount", missCount); stats.put("hitRate", hitCount + missCount > 0 ? (double) hitCount / (hitCount + missCount) : 0.0); return stats; } } // Cache Configuration class CacheConfig { private final String cacheType; private final Map<String, Object> properties; public CacheConfig(String cacheType) { this.cacheType = cacheType; this.properties = new HashMap<>(); } public CacheConfig setProperty(String key, Object value) { properties.put(key, value); return this; } public String getCacheType() { return cacheType; } public Map<String, Object> getProperties() { return new HashMap<>(properties); } public <T> T getProperty(String key, T defaultValue) { return properties.containsKey(key) ? (T) properties.get(key) : defaultValue; } } // Abstract Factory interface CacheFactory { Cache createCache(CacheConfig config); boolean supportsType(String cacheType); } // Concrete Factories class MemoryCacheFactory implements CacheFactory { @Override public Cache createCache(CacheConfig config) { int maxSize = config.getProperty("maxSize", 1000); return new MemoryCache(maxSize); } @Override public boolean supportsType(String cacheType) { return "memory".equalsIgnoreCase(cacheType); } } class DiskCacheFactory implements CacheFactory { @Override public Cache createCache(CacheConfig config) { String cacheDir = config.getProperty("cacheDir", "/tmp/cache"); return new DiskCache(cacheDir); } @Override public boolean supportsType(String cacheType) { return "disk".equalsIgnoreCase(cacheType); } } class RedisCacheFactory implements CacheFactory { @Override public Cache createCache(CacheConfig config) { String redisUrl = config.getProperty("redisUrl", "localhost"); int redisPort = config.getProperty("redisPort", 6379); return new RedisCache(redisUrl, redisPort); } @Override public boolean supportsType(String cacheType) { return "redis".equalsIgnoreCase(cacheType); } } // Factory Manager with Registration class CacheFactoryManager { private static final Map<String, CacheFactory> factories = new HashMap<>(); private static final Map<String, Cache> cacheInstances = new ConcurrentHashMap<>(); static { // Register default factories registerFactory("memory", new MemoryCacheFactory()); registerFactory("disk", new DiskCacheFactory()); registerFactory("redis", new RedisCacheFactory()); } public static void registerFactory(String cacheType, CacheFactory factory) { factories.put(cacheType.toLowerCase(), factory); } public static Cache createCache(CacheConfig config) { String cacheType = config.getCacheType().toLowerCase(); CacheFactory factory = factories.get(cacheType); if (factory == null) { throw new IllegalArgumentException("Unsupported cache type: " + cacheType); } return factory.createCache(config); } public static Cache getOrCreateCache(String cacheName, CacheConfig config) { return cacheInstances.computeIfAbsent(cacheName, k -> createCache(config)); } public static Set<String> getSupportedCacheTypes() { return new HashSet<>(factories.keySet()); } public static void clearCacheInstances() { cacheInstances.values().forEach(Cache::clear); cacheInstances.clear(); } } // Cache Manager class CacheManager { private final Map<String, Cache> caches = new ConcurrentHashMap<>(); public Cache createCache(String name, CacheConfig config) { Cache cache = CacheFactoryManager.createCache(config); caches.put(name, cache); System.out.println("Created cache: " + name + " (" + cache.getCacheType() + ")"); return cache; } public Cache getCache(String name) { return caches.get(name); } public void removeCache(String name) { Cache cache = caches.remove(name); if (cache != null) { cache.clear(); } } public Set<String> getCacheNames() { return new HashSet<>(caches.keySet()); } public void displayStats() { System.out.println("\n=== Cache Statistics ==="); caches.forEach((name, cache) -> { System.out.println("\nCache: " + name + " (" + cache.getCacheType() + ")"); Map<String, Object> stats = cache.getStats(); stats.forEach((key, value) -> System.out.printf(" %s: %s%n", key, value)); }); } } public class AdvancedCacheFactoryExample { public static void main(String[] args) { System.out.println("=== Advanced Cache Factory Pattern ==="); // Display supported cache types System.out.println("Supported cache types: " + CacheFactoryManager.getSupportedCacheTypes()); CacheManager cacheManager = new CacheManager(); // Create different types of caches createVariousCaches(cacheManager); // Test cache operations testCacheOperations(cacheManager); // Demonstrate cache statistics cacheManager.displayStats(); // Test performance testCachePerformance(); // Clean up CacheFactoryManager.clearCacheInstances(); } public static void createVariousCaches(CacheManager cacheManager) { System.out.println("\n=== Creating Various Caches ==="); // Memory cache with small size CacheConfig memoryConfig = new CacheConfig("memory") .setProperty("maxSize", 100); cacheManager.createCache("smallMemoryCache", memoryConfig); // Memory cache with large size CacheConfig largeMemoryConfig = new CacheConfig("memory") .setProperty("maxSize", 10000); cacheManager.createCache("largeMemoryCache", largeMemoryConfig); // Disk cache CacheConfig diskConfig = new CacheConfig("disk") .setProperty("cacheDir", "/var/cache/myapp"); cacheManager.createCache("diskCache", diskConfig); // Redis cache CacheConfig redisConfig = new CacheConfig("redis") .setProperty("redisUrl", "redis.example.com") .setProperty("redisPort", 6379); cacheManager.createCache("redisCache", redisConfig); System.out.println("Created caches: " + cacheManager.getCacheNames()); } public static void testCacheOperations(CacheManager cacheManager) { System.out.println("\n=== Testing Cache Operations ==="); Cache memoryCache = cacheManager.getCache("smallMemoryCache"); if (memoryCache != null) { // Basic operations memoryCache.put("key1", "value1"); memoryCache.put("key2", 12345); memoryCache.put("key3", Arrays.asList("a", "b", "c")); System.out.println("Cache size: " + memoryCache.size()); System.out.println("Get key1: " + memoryCache.get("key1")); System.out.println("Get key2: " + memoryCache.get("key2")); System.out.println("Get non-existent key: " + memoryCache.get("key999")); // Test eviction by adding more items for (int i = 0; i < 150; i++) { memoryCache.put("testKey" + i, "testValue" + i); } System.out.println("Cache size after adding 150 items: " + memoryCache.size()); // Test multiple caches Cache largeMemoryCache = cacheManager.getCache("largeMemoryCache"); if (largeMemoryCache != null) { largeMemoryCache.put("largeKey", "This is in large cache"); System.out.println("Large cache get: " + largeMemoryCache.get("largeKey")); } } } public static void testCachePerformance() { System.out.println("\n=== Cache Performance Test ==="); CacheConfig config = new CacheConfig("memory") .setProperty("maxSize", 5000); Cache cache = CacheFactoryManager.createCache(config); int operations = 1000; long startTime, endTime; // Write performance startTime = System.currentTimeMillis(); for (int i = 0; i < operations; i++) { cache.put("perfKey" + i, "perfValue" + i); } endTime = System.currentTimeMillis(); System.out.printf("Write %d operations: %d ms%n", operations, (endTime - startTime)); // Read performance startTime = System.currentTimeMillis(); for (int i = 0; i < operations; i++) { cache.get("perfKey" + i); } endTime = System.currentTimeMillis(); System.out.printf("Read %d operations: %d ms%n", operations, (endTime - startTime)); // Mixed operations startTime = System.currentTimeMillis(); for (int i = 0; i < operations; i++) { if (i % 2 == 0) { cache.put("mixedKey" + i, "mixedValue" + i); } else { cache.get("mixedKey" + (i - 1)); } } endTime = System.currentTimeMillis(); System.out.printf("Mixed %d operations: %d ms%n", operations, (endTime - startTime)); cache.clear(); } }

9. Conclusion

Key Takeaways:

Simple Factory: Static method that creates objects based on parameters
Factory Method: Subclasses decide which class to instantiate
Abstract Factory: Families of related objects without specifying concrete classes

When to Use Factory Pattern:

✅ Object creation logic is complex
✅ Need to decouple object creation from usage
✅ System should be independent of how objects are created
✅ Want to provide a library of objects that can be extended
✅ Need to create families of related objects

Benefits:

Loose coupling between client and concrete classes
Single Responsibility Principle - creation logic in one place
Open/Closed Principle - easy to introduce new types
Code organization and maintainability
Configuration flexibility

Common Use Cases:

Database connections and connection pools
Logger frameworks with different appenders
UI toolkits with different look-and-feels
Payment processors with different payment methods
Cache systems with different storage backends

Best Practices:

Use meaningful names for factory methods
Consider using configuration files for factory setup
Implement proper error handling for creation failures
Use dependency injection with factories for better testability
Consider caching for expensive object creation

Comparison:

Pattern	Use Case	Complexity	Flexibility
Simple Factory	Simple object creation	Low	Limited
Factory Method	Subclass-specific creation	Medium	High
Abstract Factory	Families of related objects	High	Very High

Final Thoughts:

The Factory Pattern is one of the most widely used creational patterns in Java. It provides:

Clean separation of object creation and business logic
Enhanced testability through dependency injection
Improved maintainability through centralized creation logic
Greater flexibility for future extensions

Master the Factory Pattern to write more flexible, maintainable, and testable Java applications!