Java Design Patterns Basics + Sample Interview Questions

Singleton

Ensures that a class has only one instance and a global access point to it.

Factory Method

Defines an interface for creating objects but allows subclasses to decide which class to instantiate.

Abstract Factory

Provides an interface for creating families of related or dependent objects without specifying their concrete classes.

Adapter

Transforms an interface into another interface expected by a client, enabling cooperation between classes that otherwise could not work together.

Bridge

Separates an abstraction from its implementation, allowing both to be developed independently.

Composite

Composes objects into tree structures to represent part-whole hierarchies, enabling clients to treat individual objects and their compositions uniformly.

Observer

Defines a one-to-many dependency between objects, so that when one object changes state, all its dependents are notified and updated.

Strategy

Defines a family of algorithms, encapsulates each one, and makes them interchangeable, allowing the algorithm used by a client to be changed dynamically.

Command

Turns a request into an object, allowing for parameterization of objects with different requests, queuing or logging requests, and supporting undoable operations.

Key Features

Single instance: guarantees that the class has only one instance.

Global access: allows global access to that instance.

Instance control: ensures control over the instantiation process.

Implementation in Java

public class SingleInstance {
    private static SingleInstance instance;
    
    // Private constructor prevents the creation of external objects.
    private SingleInstance() { }
    
    // Public method that returns a single instance of Singleton
    public static synchronized SingleInstance getInstance() { 
        if (instance == null) {
            instance = new SingleInstance(); 
        }

        return instance; 
    }
}

In the above example:

Private constructor: prevents creating instances from outside.

Static getInstance method: provides a global access point to the only instance. The synchronized keyword ensures that the method is thread-safe.

Configuration management

Singleton can be used to store and share application configuration settings, ensuring that all parts of the application use the same settings.

public class ConfigurationManager {
    private static ConfigurationManager instance; 
    private Properties config;
    
    private ConfigurationManager() {
        config = new Properties();
        // Load properties from a file
        // config.load(new FileInputStream("config.properties"));
    }
    
    public static synchronized ConfigurationManager getInstance() { 
        if (instance == null) {
            instance = new ConfigurationManager(); 
        }
    
        return instance; 
    }
    
    public String getProperty(String key) { 
        return config.getProperty(key);
    } 
}

Singleton in Spring Framework

The Spring Framework automatically manages beans in the application context as singletons. By default, every bean in Spring is a singleton, meaning that Spring manages a single instance of the bean throughout the entire application context.

An example of defining a bean as a singleton in Spring configuration:

@Configuration
public class AppConfig {

    @Bean
    public MyService myService() { 
        return new MyService();
    } 
}

In Spring, you can always create a Singleton in a very simple way, just add the @Repository, @Service, @Controller, @Component annotation, and the Spring container will take care of the rest.

Advantages of Singleton

Global access: allows access to the same instance from anywhere in the application.

Resource control: provides centralized management of resources such as configurations or database connections.

Ease of implementation: simple and intuitive design.

Disadvantages of Singleton

Testing problems: difficulty in unit testing due to global state, which can be hard to reset between tests.

Prone to misuse: can lead to overuse of global state, complicating code maintenance and understanding.

Multithreading: can be problematic in multithreaded environments if not implemented correctly (synchronization mechanisms are necessary).

Summary

Usage in Java: Integer vs int

int: primitive type representing integers (e.g., 1, 2, -3).

Integer: wrapper class for int that provides additional functionalities such as helper methods, the ability to use in generic contexts, and automatic conversion to/from primitive type. It's also possible to store null here and perform functions like equals() or toString().

int primitiveInt = 10;
Integer wrappedInt = new Integer(10);

// Can be used in a generic context
List<Integer> integerList = new ArrayList<>(); 
integerList.add(1);
integerList.add(2);

// Automatic conversion between int and Integer
int intValue = wrappedInt.intValue();

Creating a simple Wrapper in a business context

public class CustomerOrderWrapper { 
    private Customer customer; 
    private Order order;

    public CustomerOrderWrapper(Customer customer, Order order) { 
        this.customer = customer;
        this.order = order;
    }
    
    public Customer getCustomer() { 
        return customer;
    }
    
    public Order getOrder() { 
        return order;
    } 
}

In the above example, CustomerOrderWrapper wraps the customer and order objects into one wrapper, allowing operations on both objects simultaneously in the application.

Advantages of Wrappers

Interface adaptation: allows adapting existing interfaces or classes to new requirements.

Ease of using different data types: Wrappers allow for manipulating data in a more flexible way, including conversion between different types.

Disadvantages of Wrappers

Additional level of abstraction: may introduce an additional level of abstraction and complexity in the code.

Overhead associated with wrapping: may introduce a slight performance overhead associated with creating and managing wrapper objects.

Summary

Usage in Java (collections)

List<String> list = new ArrayList<>(); 
list.add("Element 1"); 
list.add("Element 2");
list.add("Element 3");

// Obtaining an iterator
Iterator<String> iterator = list.iterator();

// Iteration and display of elements
while (iterator.hasNext()) {
    String element = iterator.next(); 
    System.out.println(element);
}

In the above example, iterator() returns an Iterator for the ArrayList, which can be used to sequentially traverse through the list elements using hasNext() and next() methods

Implementing your own Iterator

public class CustomCollection {
    private String[] elements = {"A", "B", "C"};
    
    public Iterator<String> iterator() { 
        return new CustomIterator();
    }
    
    private class CustomIterator implements Iterator<String> { 
        private int index = 0;
    
        @Override
        public boolean hasNext() {
            return index < elements.length; 
        }
        
        @Override
        public String next() { 
            if (!hasNext()) {
                throw new NoSuchElementException(); 
            }
            return elements[index++]; 
        } 
    } 
}

In this example, CustomCollection contains a custom array elements, and CustomIterator is a nested class implementing the Iterator interface. This allows us to iterate over CustomCollection elements just like standard collections.

Advantages of Iterator

Separation of interface from implementation: Iterator allows access to collection elements without revealing details of its structure.

Universality: allows applying the same iterative operations for different types of collections.

Application of Iterator

Browsing and operating on collection elements: Iterator is used wherever we need sequential access to collection elements regardless of its specific implementation.

Multiple data processing: Iterator allows multiple passes through the same data without the need to copy or modify the collection structure.

Summary