Java on Aamer Paul

Strategy Pattern in Action

Sat, 02 Aug 2025 08:53:20 +0530

Strategy Pattern is a behavioral design pattern that enables selecting an algorithm’s behavior at runtime.

It’s widely used and very flexible, perfect for cases where you want to avoid complex if-else or switch statements.

Use cases

You want to replace conditionals (if-else or switch) with polymorphism.
You need to switch behavior at runtime or make it configurable. Example: User selecting payment option
You want to define multiple ways of doing something (e.g., sorting, compression, payment).

Core Concepts

The pattern consists of three main components:

Builder Design Pattern

Mon, 28 Jul 2025 18:30:20 +0530

The Builder Design Pattern is a creational design pattern that lets you construct complex objects step by step. Using Builder pattern you can use same construction process to can create different representations.

Use case

Use the Builder Pattern when:

An object has many optional fields or configurations.
You want to avoid constructor telescoping (i.e., too many overloaded constructors).
You need to create immutable objects step by step.

public class User {
    private String firstName;
    private String lastName;
    private int age;
    private String email;
    private String phone;

    public User(String firstName, String lastName) { ... }
    public User(String firstName, String lastName, int age) { ... }
    public User(String firstName, String lastName, int age, String email) { ... }

    // ...
}

In above example, you can see User class is hard to maintain and read.

Factory and Abstract Factory Design Pattern

Sun, 27 Jul 2025 10:51:59 +0530

Factory Design Pattern

Factory Pattern is creational pattern that delegate the instantiation of objects to a separate method or class.

The Factory design pattern provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that’ll be created. This pattern helps to decouple the client code from the concrete classes it needs to instantiate.

Core Components

The Factory pattern has three main components:

Singleton Design Pattern

Sat, 26 Jul 2025 11:02:04 +0530

Singleton design pattern is a creational design pattern that restricts instantiation of a class ensuring class has only one instance and provide a global point of access to it.

Common Implementations

Lazy Initialization: ensures instance is created only when it is first requested.
Eager Initialization: instance is created when the class is loaded.
Thread-Safe Implementations: ensures the singleton works correctly in multi-threaded environments, such as using synchronized methods or double-checked locking. (though double-checked locking has nuances and is sometimes considered an anti-pattern in modern Java)

Use Cases

Logging
Configuration settings
Thread pools
Caches
Device drivers

Examples

Eager initialization

public class Singleton {
    private static final Singleton instance = new Singleton();

    private EagerInitializedSingleton(){}

    public static Singleton getInstance() {
        return instance;
    }
}

Useful if your singleton class is not using a lot of resources.

Using `synchronized` method (Lazy initialization)

public class Singleton {

    // Volatile ensures visibility and prevents reordering
    private static volatile Singleton instance;

    private Singleton() {
    }

    // Thread-safe with method-level synchronization
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    public void example() {
        System.out.println("Hello from Singleton!, (using synchronized method)");
    }
}

Lazily initialization the instance.
synchronized ensures that only one thread can enter the method at a time.
It ensures lazy initialization — Singleton instance is created only when needed.
Performance overhead: Every call to getInstance() acquires a lock, even after the instance has been initialized. This is unnecessary and can be expensive under heavy load.

Double-Checked Locking (Lazy initialization)

public class Singleton {

    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) { // <- Double-check
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    public void example() {
        System.out.println("Hello from Singleton!, (double-check)");
    }

}

Lazily initialization the instance.
double check aims to minimize the overhead of synchronization.
Complex

Bill Pugh (Inner Class) - Recommended Approach

public class Singleton {
    private Singleton() {
        // Prevent reflection attack
        if (SingletonHelper.INSTANCE != null) {
            throw new RuntimeException("Use getInstance() method to get the single instance of this class");
        }
    }

    private static class SingletonHelper {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHelper.INSTANCE;
    }

    public void example() {
        System.out.println("Hello from Singleton!, (Bill Pugh)");
    }
}

Static inner helper class is loaded only when getInstance() is called.
Class loading is thread-safe.
No need for synchronized, and lazy initialization is achieved.

Drawbacks

Despite its utility, the Singleton pattern is sometimes criticized as an anti-pattern because it can:

What's new in Spring Boot 4.0? A Look Ahead

Thu, 24 Jul 2025 10:24:00 +0530

The Spring ecosystem is constantly evolving to provide developers with the best tools for building modern, robust applications. With the upcoming release of Spring Framework 7.0, the community is eagerly anticipating the next major iteration of Spring Boot: version 4.0.

Spring Boot 4.0 is a major release of the Spring Boot framework, introducing significant enhancements for developers.

Key features and improvements in Spring Boot 4 includes:

Core Enhancements

Spring Boot 4.0 is built upon Spring Framework 7.0 which is major upcoming release of Spring Framework (projected for General Availability in November 2025).

Controlling Inheritance with Java's Sealed Classes and Interfaces

Tue, 02 Jul 2024 16:25:32 +0530

Introduced as a standard feature in Java 17, sealed classes and sealed interfaces give you precise control over your class hierarchies. By declaring a class or interface as sealed, you can restrict which other classes or interfaces are allowed to extend or implement it.

This feature is a powerful tool for domain modeling, enhancing security, and working with pattern matching in switch expressions.

What are Sealed Classes?

A sealed class restricts which other classes can inherit from it. This provides better control over the class hierarchy, making your code more robust and maintainable.

Understanding Functional Interfaces in Java

Tue, 26 Mar 2024 21:25:32 +0530

A functional interface in Java is an interface that contains exactly one abstract method. Introduced in Java 8, they are the backbone of lambda expressions and the Stream API, enabling a more functional style of programming. They are also known as Single Abstract Method (SAM) interfaces.

To ensure an interface is a functional interface, you can use the @FunctionalInterface annotation. The compiler will then trigger an error if the interface does not meet the requirements.

A Deep Dive into the Java Stream API

Mon, 07 Jun 2021 18:12:23 +0530

The Stream API, introduced in Java 8, is a powerful tool for processing sequences of elements. It provides a functional approach to working with collections and arrays, allowing for expressive and efficient data manipulation. Streams don’t store data; instead, they operate on a data source, such as a Collection or an array, and enable aggregate operations.

Core Concepts

A stream pipeline consists of three parts:

A source: Where the stream originates from (e.g., a List, Set, or array).
Zero or more intermediate operations: These transform the stream into another stream. Examples include filter, map, and sorted.
A terminal operation: This produces a result or a side-effect, and triggers the execution of the pipeline. Examples include forEach, collect, and reduce.

One of the key features of streams is laziness. Intermediate operations are not executed until a terminal operation is invoked. This allows the Stream API to optimize the execution of the pipeline.

Thread-Safe Counters in Java: A Deep Dive into AtomicInteger

Tue, 19 Jan 2021 10:41:26 +0530

When building multithreaded applications in Java, ensuring data integrity is crucial. A common challenge arises when multiple threads need to update a shared counter. Without proper synchronization, you can encounter race conditions, leading to incorrect results. This is where AtomicInteger comes to the rescue.

AtomicInteger is a class from the java.util.concurrent.atomic package that provides a thread-safe way to perform atomic operations on an integer value. Unlike traditional locking mechanisms (e.g., synchronized blocks), AtomicInteger uses low-level hardware instructions to achieve thread safety with higher performance.

A Deep Dive into Java's BlockingQueue

Mon, 27 Jul 2020 20:09:10 +0530

A BlockingQueue in Java is a thread-safe queue that simplifies concurrency management by providing blocking operations. It’s a crucial tool for building robust multi-threaded applications, especially for implementing producer-consumer scenarios.

Why Do We Need `BlockingQueue`?

In multi-threaded applications, it’s common to have a scenario where one or more threads (Producers) are generating data, and one or more other threads (Consumers) are processing that data. This is known as the producer-consumer problem.

Mastering Asynchronous Programming with Java's CompletableFuture

Mon, 27 Jul 2020 12:09:10 +0530

Introduced in Java 8, CompletableFuture is a powerful class for asynchronous programming. It extends the traditional Future interface with a rich set of features for composing, combining, and handling asynchronous tasks, enabling you to write non-blocking, highly concurrent applications with ease.

Why `CompletableFuture`?

Before CompletableFuture, Java’s Future was limited. You could start an asynchronous task, but you had to block your main thread using get() to retrieve the result. This defeated the purpose of non-blocking code.

Understanding Java's hashCode() and equals() Contract

Sun, 26 Jul 2020 23:03:02 +0530

In Java, the hashCode() method, inherited from the Object class, plays a crucial role in the efficient functioning of hash-based collections like HashMap, HashSet, and Hashtable. It generates an integer hash code value for an object, which is used to determine the “bucket” where the object should be stored.

The `hashCode()` and `equals()` Contract

The most important concept to understand is the contract between hashCode() and equals():

If two objects are equal according to the equals(Object) method, then calling the hashCode() method on each of the two objects must produce the same integer result.

It is not required that if two objects are unequal according to the equals(Object) method, then calling the hashCode() method on each of the two objects must produce distinct integer results. However, producing distinct hash codes for unequal objects may improve the performance of hash tables.

In simple terms: equal objects must have equal hash codes.

Understanding Fail-Fast vs. Fail-Safe Iterators in Java

Mon, 20 Jul 2020 15:44:00 +0530

When working with collections in Java, you’ll often use iterators to traverse through their elements. However, not all iterators are created equal. Two common types you’ll encounter are fail-fast and fail-safe iterators. Understanding the difference between them is crucial for writing robust and error-free code.

Fail-Fast Iterators

Fail-fast iterators immediately throw a ConcurrentModificationException if the collection is structurally modified (i.e., elements are added or removed) at any time after the iterator is created, except through the iterator’s own remove() method.

Java on Aamer Paul

Strategy Pattern in Action

Use cases

Core Concepts

Builder Design Pattern

Use case

Factory and Abstract Factory Design Pattern

Factory Design Pattern

Core Components

Singleton Design Pattern

Common Implementations

Use Cases

Examples

Eager initialization

Using synchronized method (Lazy initialization)

Double-Checked Locking (Lazy initialization)

Bill Pugh (Inner Class) - Recommended Approach

Drawbacks

What's new in Spring Boot 4.0? A Look Ahead

Core Enhancements

Controlling Inheritance with Java's Sealed Classes and Interfaces

What are Sealed Classes?

Understanding Functional Interfaces in Java

A Deep Dive into the Java Stream API

Core Concepts

Thread-Safe Counters in Java: A Deep Dive into AtomicInteger

A Deep Dive into Java's BlockingQueue

Why Do We Need BlockingQueue?

Mastering Asynchronous Programming with Java's CompletableFuture

Why CompletableFuture?

Understanding Java's hashCode() and equals() Contract

The hashCode() and equals() Contract

Understanding Fail-Fast vs. Fail-Safe Iterators in Java

Fail-Fast Iterators

Using `synchronized` method (Lazy initialization)

Why Do We Need `BlockingQueue`?

Why `CompletableFuture`?

The `hashCode()` and `equals()` Contract