Prior to the introduction of the Collections framework in JDK 1.2, you would’ve used Arrays and Vectors to store and manage a group of objects. But they had their own share of drawbacks.

The Java Collections Framework aims to overcome these issues by providing high-performance implementations of common data structures. These allow you to focus on writing the application logic instead of focusing on low-level operations.

Then, the introduction of Generics in JDK 1.5 significantly improved the Java Collections Framework. Generics let you enforce type safety for objects stored in a collection, which enhances the robustness of your applications. You can read more about Java Generics here.

In this article, I will guide you through how to use the Java Collections Framework. We’ll discuss the different types of collections, such as Lists, Sets, Queues, and Maps. I’ll also provide a brief explanation of their key characteristics such as:

• Internal mechanisms

• Handling of duplicates

• Support for null values

• Ordering

• Synchronization

• Performance

• Key methods

• Common implementations

We’ll also walk through some code examples for better understanding, and I’ll touch on the Collections utility class and its usage.

Table of Contents:

1. Understanding the Java Collections Framework

   • Collection Interfaces

   • Decoding the Java Collections Framework Hierarchy

   • A Closer Look at Collection Interfaces

2. Java Collection Interfaces

   • Lists

   • Sets

   • Queues

   • Maps

3. Collections Utility Class

4. Conclusion

Understanding the Java Collections Framework

According to the Java documentation, “A collection is an object that represents a group of objects. A collections framework is a unified architecture for representing and manipulating collections.”

In simple terms, the Java Collections Framework helps you manage a group of objects and perform operations on them efficiently and in an organized way. It makes it easier to develop applications by offering various methods to handle groups of objects. You can add, remove, search, and sort objects effectively using the Java Collections Framework.

Collection Interfaces

In Java, an interface specifies a contract that must be fulfilled by any class that implements it. This means the implementing class must provide concrete implementations for all the methods declared in the interface.

In the Java Collections Framework, various collection interfaces like Set, List, and Queue extend the Collection interface, and they must adhere to the contract defined by the Collection interface.

Decoding the Java Collections Framework Hierarchy

Check out this neat diagram from this article that illustrates the Java Collection Hierarchy:

We’ll start from the top and work down so you can understand what this diagram is showing:

1. At the root of the Java Collections Framework is the Iterable interface, which lets you iterate over the elements of a collection.

2. The Collection interface extends the Iterable interface. This means it inherits the properties and behavior of the Iterable interface and adds its own behavior for adding, removing, and retrieving elements.

3. Specific interfaces such as List, Set, and Queue further extend the Collection interface. Each of these interfaces has other classes implementing their methods. For example, ArrayList is a popular implementation of the List interface, HashSet implements the Set interface, and so on.

4. The Map interface is part of the Java Collections Framework, but it does not extend the Collection interface, unlike the others mentioned above.

5. All the interfaces and classes in this framework are part of the java.util package.

Note: A common source of confusion in the Java Collections Framework revolves around the difference between Collection and Collections. Collection is an interface in the framework, while Collections is a utility class. The Collections class provides static methods that perform operations on the elements of a collection.

Java Collection Interfaces

By now, you’re familiar with the different types of collections that form the foundation of the collections framework. Now we’ll take a closer look at the List, Set, Queue, and Map interfaces.

In this section, we'll discuss each of these interfaces while exploring their internal mechanisms. We'll examine how they handle duplicate elements and whether they support the insertion of null values. We'll also understand the ordering of elements during insertion and their support for synchronization, which deals with the concept of thread safety. Then we’ll walk through a few key methods of these interfaces and conclude by reviewing common implementations and their performance for various operations.

Before we begin, let's talk briefly about Synchronization and Performance.

• Synchronization controls access to shared objects by multiple threads, ensuring their integrity and preventing conflicts. This is crucial for maintaining thread safety.

• When choosing a collection type, one important factor is its performance during common operations like insertion, deletion, and retrieval. Performance is usually expressed using Big-O notation. You can learn more about it here.

Lists

A List is an ordered or sequential collection of elements. It follows zero-based indexing, allowing the elements to be inserted, removed, or accessed using their index position.

1. Internal mechanism: A List is internally supported by either an array or a linked list, depending on the type of implementation. For example, an ArrayList uses an array, while a LinkedList uses a linked list internally. You can read more about LinkedList here. A List dynamically resizes itself upon the addition or removal of elements. The indexing-based retrieval makes it a very efficient type of collection.

2. Duplicates: Duplicate elements are allowed in a List, which means there can be more than one element in a List with the same value. Any value can be retrieved based on the index at which it is stored.

3. Null: Null values are also allowed in a List. Since duplicates are permitted, you can also have multiple null elements.

4. Ordering: A List maintains insertion order, meaning the elements are stored in the same order they are added. This is helpful when you want to retrieve elements in the exact order they were inserted.

5. Synchronization: A List is not synchronized by default, which means it doesn't have a built-in way to handle access by multiple threads at the same time.

6. Key methods: Here are some key methods of a List interface: add(E element), get(int index), set(int index, E element), remove(int index), and size(). Let's look at how to use these methods with an example program.

    import java.util.ArrayList;
    import java.util.List;
   
    public class ListExample {
        public static void main(String[] args) {
            // Create a list
            List<String> list = new ArrayList<>();
   
            // add(E element)
            list.add("Apple");
            list.add("Banana");
            list.add("Cherry");
   
            // get(int index)
            String secondElement = list.get(1); // "Banana"
   
            // set(int index, E element)
            list.set(1, "Blueberry");
   
            // remove(int index)
            list.remove(0); // Removes "Apple"
   
            // size()
            int size = list.size(); // 2
   
            // Print the list
            System.out.println(list); // Output: [Blueberry, Cherry]
   
            // Print the size of the list
            System.out.println(size); // Output: 2
        }
    }
   

7. Common implementations: ArrayList, LinkedList, Vector, Stack

8. Performance: Typically, insert and delete operations are fast in both ArrayList and LinkedList. But fetching elements can be slow because you have to traverse through the nodes.

Sets

A Set is a type of collection that does not allow duplicate elements and represents the concept of a mathematical set.

1. Internal mechanism: A Set is internally backed by a HashMap. Depending on the implementation type, it is supported by either a HashMap, LinkedHashMap, or a TreeMap. I have written a detailed article about how HashMap works internally here. Be sure to check it out.

2. Duplicates: Since a Set represents the concept of a mathematical set, duplicate elements are not allowed. This ensures that all elements are unique, maintaining the integrity of the collection.

3. Null: A maximum of one null value is allowed in a Set because duplicates are not permitted. But this does not apply to the TreeSet implementation, where null values are not allowed at all.

4. Ordering: Ordering of elements in a Set depends on the type of implementation.

   • HashSet: Order is not guaranteed, and elements can be placed in any position.

   • LinkedHashSet: This implementation maintains the insertion order, so you can retrieve the elements in the same order they were inserted.

   • TreeSet: Elements are inserted based on their natural order. Alternatively, you can control the insertion order by specifying a custom comparator.

5. Synchronization: A Set is not synchronized, meaning you might encounter concurrency issues, like race conditions, which can affect data integrity if two or more threads try to access a Set object simultaneously

6. Key methods: Here are some key methods of a Set interface: add(E element), remove(Object o), contains(Object o), and size(). Let's look at how to use these methods with an example program.

    import java.util.HashSet;
    import java.util.Set;
   
    public class SetExample {
        public static void main(String[] args) {
            // Create a set
            Set<String> set = new HashSet<>();
   
            // Add elements to the set
            set.add("Apple");
            set.add("Banana");
            set.add("Cherry");
   
            // Remove an element from the set
            set.remove("Banana");
   
            // Check if the set contains an element
            boolean containsApple = set.contains("Apple");
            System.out.println("Contains Apple: " + containsApple);
   
            // Get the size of the set
            int size = set.size();
            System.out.println("Size of the set: " + size);
        }
    }
   

7. Common implementations: HashSet, LinkedHashSet, TreeSet

8. Performance: Set implementations offer fast performance for basic operations, except for a TreeSet, where the performance can be relatively slower because the internal data structure involves sorting the elements during these operations.

Queues

A Queue is a linear collection of elements used to hold multiple items before processing, usually following the FIFO (first-in-first-out) order. This means elements are added at one end and removed from the other, so the first element added to the queue is the first one removed.

1. Internal mechanism: The internal workings of a Queue can differ based on its specific implementation.

   • LinkedList – uses a doubly-linked list to store elements, which means you can traverse both forward and backward, allowing for flexible operations.

   • PriorityQueue – is internally backed by a binary heap, which is very efficient for retrieval operations.

   • ArrayDeque – is implemented using an array that expands or shrinks as elements are added or removed. Here, elements can be added or removed from both ends of the queue.

2. Duplicates: In a Queue, duplicate elements are permitted, allowing multiple instances of the same value to be inserted

3. Null: You cannot insert a null value into a Queue because, by design, some methods of a Queue return null to indicate that it is empty. To avoid confusion, null values are not allowed.

4. Ordering: Elements are inserted based on their natural order. Alternatively, you can control the insertion order by specifying a custom comparator.

5. Synchronization: A Queue is not synchronized by default. But, you can use a ConcurrentLinkedQueue or a BlockingQueue implementation for achieving thread safety.

6. Key methods: Here are some key methods of a Queue interface: add(E element), offer(E element), poll(), and peek(). Let's look at how to use these methods with an example program.

    import java.util.LinkedList;
    import java.util.Queue;
   
    public class QueueExample {
        public static void main(String[] args) {
            // Create a queue using LinkedList
            Queue<String> queue = new LinkedList<>();
   
            // Use add method to insert elements, throws exception if insertion fails
            queue.add("Element1");
            queue.add("Element2");
            queue.add("Element3");
   
            // Use offer method to insert elements, returns false if insertion fails
            queue.offer("Element4");
   
            // Display queue
            System.out.println("Queue: " + queue);
   
            // Peek at the first element (does not remove it)
            String firstElement = queue.peek();
            System.out.println("Peek: " + firstElement); // outputs "Element1"
   
            // Poll the first element (retrieves and removes it)
            String polledElement = queue.poll();
            System.out.println("Poll: " + polledElement); // outputs "Element1"
   
            // Display queue after poll
            System.out.println("Queue after poll: " + queue);
        }
    }
   

7. Common implementations: LinkedList, PriorityQueue, ArrayDeque

8. Performance: Implementations like LinkedList and ArrayDeque are usually quick for adding and removing items. The PriorityQueue is a bit slower because it inserts items based on the set priority order.

Maps

A Map represents a collection of key-value pairs, with each key mapping to a single value. Although Map is part of the Java Collection framework, it does not extend the java.util.Collection interface.

1. Internal mechanism: A Map works internally using a HashTable based on the concept of hashing. I have written a detailed article on this topic, so give it a read for a deeper understanding.

2. Duplicates: A Map stores data as key-value pairs. Here, each key is unique, so duplicate keys are not allowed. But duplicate values are permitted.

3. Null: Since duplicate keys are not allowed, a Map can have only one null key. As duplicate values are permitted, it can have multiple null values. In the TreeMap implementation, keys cannot be null because it sorts the elements based on the keys. However, null values are allowed.

4. Ordering: Insertion order of a Map varies on the implementation:

   • HashMap – the insertion order is not guaranteed as they are determined based on the concept of hashing.

   • LinkedHashMap – the insertion order is preserved and you can retrieve the elements back in the same order that they were added into the collection.

   • TreeMap – Elements are inserted based on their natural order. Alternatively, you can control the insertion order by specifying a custom comparator.

5. Synchronization: A Map is not synchronized by default. But you can use Collections.synchronizedMap() or ConcurrentHashMap implementations for achieving thread safety.

6. Key methods: Here are some key methods of a Map interface: put(K key, V value), get(Object key), remove(Object key), containsKey(Object key), and keySet(). Let's look at how to use these methods with an example program.

    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
   
    public class MapMethodsExample {
        public static void main(String[] args) {
            // Create a new HashMap
            Map<String, Integer> map = new HashMap<>();
   
            // put(K key, V value) - Inserts key-value pairs into the map
            map.put("Apple", 1);
            map.put("Banana", 2);
            map.put("Orange", 3);
   
            // get(Object key) - Returns the value associated with the key
            Integer value = map.get("Banana");
            System.out.println("Value for 'Banana': " + value);
   
            // remove(Object key) - Removes the key-value pair for the specified key
            map.remove("Orange");
   
            // containsKey(Object key) - Checks if the map contains the specified key
            boolean hasApple = map.containsKey("Apple");
            System.out.println("Contains 'Apple': " + hasApple);
   
            // keySet() - Returns a set view of the keys contained in the map
            Set<String> keys = map.keySet();
            System.out.println("Keys in map: " + keys);
        }
    }
   

7. Common implementations: HashMap, LinkedHashMap, TreeMap, Hashtable, ConcurrentHashMap

8. Performance: HashMap implementation is widely used mainly due to its efficient performance characteristics depicted in the below table.

Collections Utility Class

As highlighted at the beginning of this article, the Collections utility class has several useful static methods that let you perform commonly used operations on the elements of a collection. These methods help you reduce the boilerplate code in your application and lets you focus on the business logic.

Here are some key features and methods, along with what they do, listed briefly:

1. Sorting: Collections.sort(List<T>) – this method is used to sort the elements of a list in ascending order.

2. Searching: Collections.binarySearch(List<T>, key) – this method is used to search for a specific element in a sorted list and return its index.

3. Reverse order: Collections.reverse(List<T>) – this method is used to reverse the order of elements in a list.

4. Min/Max Operations: Collections.min(Collection<T>) and Collections.max(Collection<T>) – these methods are used to find the minimum and maximum elements in a collection, respectively.

5. Synchronization: Collections.synchronizedList(List<T>) – this method is used to make a list thread-safe by synchronizing it.

6. Unmodifiable Collections: Collections.unmodifiableList(List<T>) – this method is used to create a read-only view of a list, preventing modifications.

Here's a sample Java program that demonstrates various functionalities of the Collections utility class:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class CollectionsExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(5);
        numbers.add(3);
        numbers.add(8);
        numbers.add(1);

        // Sorting
        Collections.sort(numbers);
        System.out.println("Sorted List: " + numbers);

        // Searching
        int index = Collections.binarySearch(numbers, 3);
        System.out.println("Index of 3: " + index);

        // Reverse Order
        Collections.reverse(numbers);
        System.out.println("Reversed List: " + numbers);

        // Min/Max Operations
        int min = Collections.min(numbers);
        int max = Collections.max(numbers);
        System.out.println("Min: " + min + ", Max: " + max);

        // Synchronization
        List<Integer> synchronizedList = Collections.synchronizedList(numbers);
        System.out.println("Synchronized List: " + synchronizedList);

        // Unmodifiable Collections
        List<Integer> unmodifiableList = Collections.unmodifiableList(numbers);
        System.out.println("Unmodifiable List: " + unmodifiableList);
    }
}

This program demonstrates sorting, searching, reversing, finding minimum and maximum values, synchronizing, and creating an unmodifiable list using the Collections utility class.

Conclusion

In this article, you’ve learned about the Java Collections Framework and how it helps manage groups of objects in Java applications. We explored various collection types like Lists, Sets, Queues, and Maps and gained insight into some of the key characteristics and how each of these types supports them.

You learned about performance, synchronization, and key methods, gaining valuable insights into choosing the right data structures for your needs.

By understanding these concepts, you can fully utilize the Java Collections Framework, allowing you to write more efficient code and build robust applications.

If you found this article interesting, feel free to check out my other articles on freeCodeCamp and connect with me on LinkedIn.

But how do applications interact with each other? Well, they do it through APIs – Application Programming Interfaces. In this article, you’ll learn what APIs are. We’ll specifically focus on Web APIs and their design and development.

What is a Web API?

Web APIs are a type of API designed to be used over the web. In other words, web-based software applications, systems, and services use Web APIs to exchange information over the internet. They send requests and receive responses, typically in formats such as JSON or XML.

Web APIs play a crucial role in modern software development for the following reasons:

1. Interoperability: APIs are technology-agnostic, meaning they allow different software systems to communicate with each other regardless of the technology stack. This enables developers to integrate various applications seamlessly.

2. Scalability: Web APIs support modular development, enabling different components of an application to be built, debugged, and scaled independently. This greatly improves the system's scalability.

3. Flexibility and Extensibility: By following standard practices and well-defined rules, Web APIs help applications extend their functionality. They are also flexible enough to allow developers to create dynamic applications.

Approaches to Developing Web APIs

Web APIs can be developed using various methods based on the requirements. Here are some commonly followed approaches:

• REST – Representational State Transfer (REST) APIs use the HTTP protocol to perform operations. They operate in a stateless manner, meaning each request must include all the necessary information for the receiver to process and respond.

• SOAP – Simple Object Access Protocol uses XML to exchange information in a structured way.

• GraphQL – used for querying and manipulating APIs.

• gRPC – a Remote Procedure Call framework that uses HTTP/2 for transporting information.

In the upcoming sections, we will explore the design and development of APIs, focusing on REST APIs as the protocol central to our discussion.

Understanding the Requirements and Objectives

In any software development process, it's crucial to understand the requirements and intended use-case before starting. This helps you plan and estimate the cost, time, and other resources you’ll need for the project.

The same applies when building RESTful APIs. You need to determine if the applications will exchange information in a stateless manner, if the entities involved can be represented as resources, and if the services are flexible enough to work with different data formats.

Defining the Resources and Endpoints

REST APIs revolve around resources, which are entities representing the data or objects in the system. Each resource is identified by a unique URI called a resource identifier. These resources can be accessed and manipulated via endpoints, which are specific URLs that receive and process requests from the client.

Best practices suggest using nouns for resources in the endpoints instead of verbs that might indicate an operation on the resource.

Consider the following example: https://api.example.com/products

The endpoint follows the best practice of using a noun for the resource (in this case, products). Notice how I used the plural form - products? It is also advisable to use plurals if you are working with a collection of objects.

However, the following endpoint https://api.example.com/add-product is not recommended because it uses a verb and tries to describe an action on the resource. This approach can become complicated for more complex operations.

Another important aspect of standard endpoint naming convention is using a hierarchical structure. This helps to clearly represent the relationship between resources.

For example: https://api.example.com/categories/{categoryId}/products/{productId}.
Here, we define an endpoint that maintains a clear hierarchy between the category and product resources.

Using HTTP Methods and Status Codes

In REST APIs, HTTP is used for communication between the client and the server. HTTP has standard methods that are primarily used to perform operations on resources. Below is a list of these methods along with their purposes:

• GET – Fetch the details of the resource. These details are returned by the server in the response message body.

• POST – Create a new resource. The details of the resource to be created are sent in the request message body.

• PUT – Create or update a resource, depending on its availability. The details of the resource to be created or updated are sent in the request message body.

• DELETE – Remove a resource.

• PATCH – Partially update a resource. The changes to be made to the resource are sent in the request message body.

The recommended approach to developing a well-defined REST API is to use these HTTP methods correctly for performing the corresponding CRUD (Create, Read, Update, Delete) operations on the resource. Also, you should make sure that the API responds back to the client with an appropriate HTTP status code in the response message body.

Status codes reflect the end result of a request. Below are some of the common HTTP status codes you can use:

• 200 OK

• 201 Created

• 204 No Content

• 400 Bad Request

• 401 Unauthorized

• 403 Forbidden

• 404 Not Found

• 500 Internal Server Error

• 503 Service Unavailable

• 504 Gateway Timeout

Use a suitable HTTP status code that accurately represents the outcome of the request your API endpoint is processing. You can also implement custom HTTP status code to describe application-specific behavior.

Versioning Strategies

Over time, the API you develop will evolve, and you will make changes to it. This is where versioning strategies become important. You must ensure that the clients already using your APIs are not affected by the changes you make.

Maintaining different versions will make your APIs backward compatible and allow clients to use the preferred version of the API based on their needs. An excerpt from this informative blog on the Postman website explains when it is ideal to version your APIs:

“You should version your API whenever you make a change that will require consumers to modify their codebase in order to continue using the API. This type of change is known as a “breaking change,” and it can be made to an API's input and output data structures, success and error feedback, and security mechanisms.“

API versioning can be done in different ways. Here are some methods:

• URI Versioning: Include the version number in the URL path. For example, https://api.example.com/v1/products.

• Query Parameter Versioning: Specify the version number as a query parameter in the URL. For example, https://api.example.com/products?version=1.

• Header Versioning: Include the version number in the HTTP headers of the request. For example, using a custom header like X-API-Version: 1.

• Content Negotiation: Specify the version in the Accept header of the request, often using media types. For example, Accept: application/vnd.example.v1+json.

• Embedded Versioning: Embed the version number within the media type of the response. For example, application/vnd.example.product-v1+json.

Security Considerations

Another important aspect to consider when developing an API is security. Here are some key points to remember:

1. Implement HTTPS to encrypt the information exchanged between the client and the server.

2. Implement authentication and authorization to ensure that only users with the right privileges can perform operations on the resources. Common methods include Basic authentication, Bearer or Token authentication, JWT, and OAuth 2.0. Also, implement role-based access control to manage resource access.

3. Implement input validation and sanitization to prevent vulnerability attacks like SQL injection and Cross-Site Scripting (XSS).

4. Implement rate limiting and throttling to control the number of requests a client can make to the server within a specific time frame. This helps prevent excessive load on the server.

Documentation

One key but often overlooked aspect of API development is documentation. It is crucial to document your API so users understand its features and functionalities.

The documentation must be comprehensive, easy to understand, and follow standard practices. Include examples of request and response bodies, HTTP status codes used, and more. You can follow the Open API specification for describing your RESTful APIs.

Sorting, Filtering and Pagination Strategies

The API you develop might cause performance issues if it returns too many records. It's inefficient to retrieve large amounts of data and then sort or filter it.

To address this, you should enable sorting and filtering of records. You should also implement pagination to break down the number of records being fetched and set a limit for easier navigation and processing.

Monitoring Usage, Logging, and Health

It’s a good idea to log your API requests and responses to help with debugging. Monitoring API usage will help you understand the overall performance and behavior of the application. Performing regular health checks can help you take necessary action if there are any issues. All these steps will make the API more robust and reliable.

Conclusion

APIs, specifically Web APIs, are essential for software applications to communicate over the internet.

This article explained what Web APIs are, why they’re important, and different approaches for developing them, focusing on REST APIs. You also learned about key topics like defining resources and endpoints, using standard HTTP methods and status codes, versioning strategies, security considerations, documentation, and more.

If you found this article interesting, feel free to check out my other articles on freeCodeCamp and connect with me on LinkedIn.

In this article, I will introduce you to HashMaps in Java. We will explore the common operations of HashMap and then delve into how it operates internally. You will gain an understanding of the hash function and how index calculation takes place. Finally, we will look at the time complexities of the operations and touch upon the behavior in a concurrent environment.

What is a HashMap in Java?

A HashMap implements the Map interface, which is part of the Java collection framework. It's based on the concept of Hashing.

Hashing is a technique that transforms an input of arbitrary size into a fixed-size output using a hash function. The generated output is called the hash code and is represented by an integer value in Java. Hash codes are used for efficient lookup and storage operations in a HashMap.

Common Operations

Like we discussed above, data in a HashMap is stored in the form of key-value pairs. The key is a unique identifier, and each key is associated with a value.

Below are some common operations supported by a HashMap. Let's understand what these methods do with some simple code examples:

Insertion

• This method inserts a new key-value pair to the HashMap.

• The insertion order of the key-value pairs is not maintained.

• During insertion, if a key is already present, the existing value will be replaced with the new value that is passed.

• You can insert only one null key into the HashMap, but you can have multiple null values.

The method signature for this operation is given below, followed by an example:

public V put(K key, V value)

Map<String, Integer> map = new HashMap<>();
map.put("apple", 1);
map.put("banana", 2);

In the code above, we have a HashMap example where we add a key of type String and value of type Integer.

Retrieval:

• Fetches the value associated with a given key.

• Returns null if the key does not exist in the HashMap.

The method signature for this operation is given below, followed by an example:

public V get(Object key)

Integer value = map.get("apple"); // returns 1

In the code above, we're retrieving the value associated with the key apple.

Other common operations include:

• remove: Removes the key-value pair for the specified key. It returns null if the key is not found.

• containsKey: Checks if a specific key is present in the HashMap.

• containsValue: Checks if the specified value is present in the HashMap.

Internal Structure of a HashMap

Internally, a HashMap uses an array of buckets or bins. Each bucket is a linked list of type Node, which is used to represent the key-value pair of the HashMap.

static class Node<K, V> {
    final int hash;
    final K key;
    V value;
    Node<K, V> next;

    Node(int hash, K key, V value, Node<K, V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }
}

Above, you can see the structure of the Node class which is used to store the key-value pairs of the HashMap.

The Node class has the following fields:

• hash: Refers to the hashCode of the key.

• key: Refers to the key of the key-value pair.

• value: Refers to the value associated with the key.

• next: Acts as a reference to the next node.

The HashMap is fundamentally based on a hash table implementation, and its performance depends on two key parameters: initial capacity and load factor. The original javadocs of the Hash table class define these two parameters as follows:

• The capacity is the number of buckets in the hash table, and the initial capacity is simply the capacity at the time the hash table is created.

• The load factor is a measure of how full the hash table is allowed to get before its capacity is automatically increased.

Let's now try and understand how the basic operations, put and get, work in a HashMap.

Hash Function

During the insertion (put) of a key-value pair, the HashMap first calculates the hash code of the key. The hash function then computes an integer for the key. Classes can use the hashCode method of the Object class or override this method and provide their own implementation. (Read about the hash code contract here). The hash code is then XORed (eXclusive OR) with its upper 16 bits (h >>> 16) to achieve a more uniform distribution.

XOR is a bitwise operation that compares two bits, resulting in 1 if the bits are different and 0 if they are the same. In this context, performing a bitwise XOR operation between the hash code and its upper 16 bits (obtained using the unsigned right shift >>> operator) helps to mix the bits, leading to a more evenly distributed hash code.

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

Above, you can see the static hash method of the HashMap class.

The idea is to have a unique hash code for each key, but the hash function could produce the same hash code for different keys. This leads to a situation known as a collision. We will see how to handle collisions in the next section.

Index Calculation

Once the hash code for a key is generated, the HashMap calculates an index within the array of buckets to determine where the key-value pair will be stored. This is done using a bitwise AND operation, which is an efficient way to calculate the modulo when the array length is a power of two.

int index = (n - 1) & hash;

Here, we're calculating the index where n is the length of the bucket array.

Once the index is calculated, the key is then stored at that index in the bucket array. However, if multiple keys end up having the same index, it causes a collision. In such a scenario, the HashMap handles it in one of two ways:

• Chaining/Linking: Each bucket in the array is a linked list of nodes. If a key already exists at a particular index and another key gets hashed to the same index, it gets appended to the list.

• Treeify: If the number of nodes exceeds a certain threshold, the linked list is converted into a tree (This was introduced in Java 8).

static final int TREEIFY_THRESHOLD = 8;

This is the threshold that determines treeification.

Therefore, it is essential to have a good hash function that uniformly distributes the keys across the buckets and minimizes the chances of collisions.

The retrieval (get) and deletion (remove) operations work similarly to the insertion (put) operation. Here's how:

• Retrieval (get): Computes the hash code using the hash function -> calculates the index using the hash code -> traverses the linked list or tree to find the node with the matching key.

• Deletion (remove): Computes the hash code using the hash function -> calculates the index using the hash code -> removes the node from the linked list or tree.

Time Complexity

The basic operations of a HashMap, such as put, get, and remove, generally offer constant time performance of O(1), assuming that the keys are uniformly distributed. In cases where there is poor key distribution and many collisions occur, these operations might degrade to a linear time complexity of O(n).

Under treeification, where long chains of collisions are converted into balanced trees, lookup operations can improve to a more efficient logarithmic time complexity of O(log n).

Synchronization

The HashMap implementation is not synchronized. If multiple threads access a HashMap instance concurrently and iterate over the map, and if any one of the threads performs a structural modification (such as adding or removing a key-value mapping) on the map, it leads to a ConcurrentModificationException.

To prevent this, you can create a thread-safe instance using the Collections.synchronizedMap method.

Conclusion

In summary, understanding the internal workings of a HashMap is crucial for developers to make informed decisions. Knowing how a key is mapped, how collisions happen, and how they can be avoided helps you use the HashMap efficiently and effectively.

The design patterns are classified into three categories based on their purpose:

• Creational
• Structural
• Behavioral

In this article, I will walk you through what creational design patterns are, take a look at the different types, and explore some of them using Java code examples.

##Creational Design Patterns

As the name suggests, creational design patterns deal with object creation. They provide different ways for you to create objects. Following these design patterns will ensure that the object instantiation process is flexible and highly efficient. This is achieved by making the system independent of the creation, composition, and representation of the object.

There are five different types of creational design patterns:

1. Singleton
2. Factory Method
3. Abstract Factory
4. Builder
5. Prototype

In the following sections, we'll talk about these design patterns by defining them, providing code examples, and explaining their potential use cases.

##Singleton Design Pattern

A singleton design pattern ensures that there is only one instance of a class throughout your application. You're allowed to create only one object of the singleton class, and any subsequent call to create another object of the same class will return the existing object reference.

This allows you to have a single point of access to the object across your application. Let's take a look at the code for implementing the singleton pattern:

public class Singleton {

    private static Singleton instance;

    private Singleton() {

    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    public void displayMessage() {
        System.out.println("Hello, I am a Singleton instance!");
    }

    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();

        singleton.displayMessage();
    }
}

In the above example, you'll notice the three crucial aspects you must remember when implementing a singleton class:

• A private static instance
• A private constructor
• A public static method

The private static instance is of the same type as the class itself, and it is marked static as it needs to be accessed only through the class reference and not by creating an object.

The constructor of the class is marked private to prevent objects of the class from being created.

We also have a public static method named getInstance, which first checks if the instance is null. If it is, then it allows a new instance of the class to be created. Otherwise, it returns the existing instance reference.

We created an instance of the Singleton class by calling the static getInstance method.

###Use Cases

Here are a few cases where you might use the singleton design pattern:

• Database connections: These operations are expensive, so to avoid the overhead of repeatedly opening and closing the connections, you can implement the singleton design pattern to reuse existing connections from the pool.
• Logging: You can have a single instance of the logger to log the messages in your application to promote efficiency and consistency.
• Configuration: You can have a single, centralized configuration manager for loading the settings from any source and use it across the application

Note: There are a few other variations of implementing a singleton class, but we will not be exploring those in this article. Additionally, what we have seen above is a simple implementation in a single-threaded application. There are chances that you may encounter some challenges with this in a multi-threaded environment and addressing that is also beyond the scope of this article.

##Factory Method Design Pattern

In the book "Design Patterns: Elements of Reusable Object-Oriented Software" the authors (referred to as the Gang of Four or GoF) define the factory method as follows:

defines an interface for creating an object, but let subclasses decide which class to instantiate

As the definition shows, in the factory method design pattern, an interface is provided for creating objects. Various classes implement this interface and return instances of their respective types. A factory then determines which type of object should be returned based on predefined conditions.

This design pattern encapsulates the instantiation logic, decouples the object creation process, making your code more flexible, and promotes extensibility. Let us take a look at the code example for better understanding:

1. We define an interface Shape:

public interface Shape {
    void draw();
}

2. We create concrete implementions of the Shape class named Square and Circle:

public class Square implements Shape {
    public void draw() {
        System.out.println("Drawing a Square");
    }
}

public class Circle implements Shape {
    public void draw() {
        System.out.println("Drawing a Circle");
    }
}

3. We define a ShapeFactory interface for creating the objects of type Shape:

public interface ShapeFactory {
    Shape createShape();
}

4. Finally, we implement concrete factories:

public class SquareFactory implements ShapeFactory {
    public Shape createShape() {
        return new Square();
    }
}

public class CircleFactory implements ShapeFactory {
    public Shape createShape() {
        return new Circle();
    }
}

5. The client uses the factory to create objects of different shapes:

public class Main {

    public static void main(String[] args) {
        ShapeFactory squareFactory = new SquareFactory();
        Shape square = squareFactory.createShape();
        square.draw();

        ShapeFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.createShape();
        circle.draw();
    }
}

This way, we can ensure that the client code is decoupled from the specific classes, as it does not need to instantiate those objects directly. This makes it easier to add new shapes.

###Use Cases:

• Database Connections: You can set up a DatabaseConnectionFactory in your application to connect to different types of databases (for example: MySQL, PostgreSQL, Oracle)
• User Authentication: You can set up an AuthenticationFactory that supports different authentication methods (for example: OAuth, SAML, LDAP)

##Abstract Factory Design Pattern

We will once again refer to the book "Design Patterns: Elements of Reusable Object-Oriented Software" for the definition of abstract factory. It states:

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

This means that you have a super-factory that allows you to create a group of related factories. You can think of the abstract factory design pattern as a factory of factories, providing an additional layer of abstraction over the factory method design pattern we discussed earlier.

Let us take an example of the abstract factory design pattern using the idea of a CarFactory to create different types of cars.

1. We define a common interface for all cars named Car:

public interface Car {
    void drive();
}

2. We create concrete implementations of the Car interface named Sedan and SUV:

public class Sedan implements Car {
    @Override
    public void drive() {
        System.out.println("Driving a Sedan");
    }
}

public class SUV implements Car {
    @Override
    public void drive() {
        System.out.println("Driving an SUV");
    }
}

3. We define an interface for car factories named CarFactory:

public interface CarFactory {
    Car createCar();
}

4. We define concrete factories named SedanFactory and SUVFactory that create Sedan and SUV cars respectively:

public class SedanFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Sedan();
    }
}

public class SUVFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new SUV();
    }
}

5. The AbstractCarFactory class defines an abstract class for creating different car factories:

public abstract class AbstractCarFactory {
    public abstract CarFactory getCarFactory(String type);
}

6. The ConcreteCarFactory class implements the AbstractCarFactory to return the appropriate factory based on the type of the car:

public class ConcreteCarFactory extends AbstractCarFactory {
    @Override
    public CarFactory getCarFactory(String type) {
        if (type.equalsIgnoreCase("Sedan")) {
            return new SedanFactory();
        } else if (type.equalsIgnoreCase("SUV")) {
            return new SUVFactory();
        }
        return null;
    }
}

7. Finally, in the client code, we use the abstract factory design pattern to create Sedan and SUV cars without specifying their concrete classes:

public class Main {
    public static void main(String[] args) {
        AbstractCarFactory carFactory = new ConcreteCarFactory();

        CarFactory sedanFactory = carFactory.getCarFactory("Sedan");
        Car sedan = sedanFactory.createCar();
        sedan.drive();  // Output - Driving a Sedan

        CarFactory suvFactory = carFactory.getCarFactory("SUV");
        Car suv = suvFactory.createCar();
        suv.drive();  // Output -  Driving an SUV
    }
}

###Use Cases

• When you want to have a system that is independent of the creation, composition, and representation of its components.
• When you want to configure a system with a family of related components.

##Builder Design Pattern

The builder design pattern is another creational design pattern used to construct complex objects. You might encounter a class with many parameters required to create an instance. Some can be mandatory, while some can be optional. Using the builder design pattern, you can separate the process of creating such complex objects from their representation.

Let me give you an example:

public class Person {

    private final String firstName;
    private final String lastName;

    private final int age;
    private final String address;
    private final String phoneNumber;

    private Person(PersonBuilder builder) {
        this.firstName = builder.firstName;
        this.lastName = builder.lastName;
        this.age = builder.age;
        this.address = builder.address;
        this.phoneNumber = builder.phoneNumber;
    }

    // Getters for all the parameters

    @Override
    public String toString() {
        return "Person{" +
                "firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                ", phoneNumber='" + phoneNumber + '\'' +
                '}';
    }

    public static class PersonBuilder {

        private final String firstName;
        private final String lastName;

        private int age;
        private String address;
        private String phoneNumber;

        public PersonBuilder(String firstName, String lastName) {
            this.firstName = firstName;
            this.lastName = lastName;
        }

        public PersonBuilder age(int age) {
            this.age = age;
            return this;
        }

        public PersonBuilder address(String address) {
            this.address = address;
            return this;
        }

        public PersonBuilder phoneNumber(String phoneNumber) {
            this.phoneNumber = phoneNumber;
            return this;
        }

        public Person build() {
            return new Person(this);
        }
    }
}

In the above example, we have a Person class that contains a few required parameters (firstName and lastName) and some optional parameters (age, address, phoneNumber). The constructor is also marked private so that only the PersonBuilder class associated with this is allowed to access it.

The PersonBuilder class has the same properties as the Person class. The required parameters are set via its constructor. It also has suitable methods for setting the optional parameters that return this and enable method chaining.

public class Main {
    public static void main(String[] args) {
        Person person = new Person.PersonBuilder("Mikel", "Arteta")
                .age(42)
                .address("1 North London")
                .phoneNumber("111-1234")
                .build();

        System.out.println(person);
    }
}

To use this, we created a PersonBuilder instance with the required parameters. We set the optional parameters using method chaining. Finally, we called the build() method to create a Person object.

###Use Cases:

• You can use the builder design pattern when you want to construct a complex object of a class that has a combination of mandatory and optional properties.
• You can use this when your class has many parameters and is inefficient to have different constructors for each combination of the parameters.
• You can use it to provide different representations of the same object to the client.

##Prototype Design Pattern

There could be a scenario where you want to create an object that is similar to an existing object. The prtotype design pattern allows you to achieve this. In this pattern, the existing object is known as the prototype, and the idea is that it is much more efficient to copy an existing object than to create a new one from scratch.

It might not be possible for you to create an exact copy of the prototype because some fields of that object might be marked as private. This can be overcome by using the clone method approach. We create a common interface that includes only a clone method, and all classes that support the cloning of their objects implement this interface. Let us take a look at the code example for this:

1. We create a Prototype interface that defines a clone method that classes must implement:

public interface Prototype extends Cloneable {
    Prototype clone();
}

2. We create Circle and Rectangle which are concrete classes that implement the Prototype interface:

public class Circle implements Prototype {
    private int radius;

    public Circle(int radius) {
        this.radius = radius;
    }

    public int getRadius() {
        return radius;
    }

    public void setRadius(int radius) {
        this.radius = radius;
    }

    @Override
    public Prototype clone() {
        return new Circle(this.radius);
    }

    @Override
    public String toString() {
        return "Circle with radius: " + radius;
    }
}

public class Rectangle implements Prototype {
    private int width;
    private int height;

    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }

    public int getWidth() {
        return width;
    }

    public void setWidth(int width) {
        this.width = width;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    @Override
    public Prototype clone() {
        return new Rectangle(this.width, this.height);
    }

    @Override
    public String toString() {
        return "Rectangle with width: " + width + " and height: " + height;
    }
}

3. In the client code, we create the original objects (originalCircle and originalRectangle) and then we clone them to create new instances (clonedCircle and clonedRectangle)

Note that the cloned instances can be modified independently of the original objects.

public class Main {
    public static void main(String[] args) {
        Circle originalCircle = new Circle(10);
        Circle clonedCircle = (Circle) originalCircle.clone();
        clonedCircle.setRadius(20);

        System.out.println(originalCircle);  
        System.out.println(clonedCircle);    

        Rectangle originalRectangle = new Rectangle(15, 25);
        Rectangle clonedRectangle = (Rectangle) originalRectangle.clone();
        clonedRectangle.setWidth(30);
        clonedRectangle.setHeight(50);

        System.out.println(originalRectangle);  
        System.out.println(clonedRectangle);    
    }
}

###Use Cases

• Follow the prototype design pattern when the object you want to create involves a complex construction process.
• Use it when the object initialization is costly and involves a lot of expensive resources.

##Conclusion

In this article, we explored the creational design patterns and delved into code examples and use cases. Understanding these patterns and their application will help you make your code more extensible and maintainable.

Connect with me on LinkedIn

In this article, you'll learn about generics and see how they can help address this problem.

##Why Do We Need Generics?

Let's begin with a simple example. We will first add different types of objects to an ArrayList. Next, we will try to retrieve them and print their values.

List list = new ArrayList();

list.add("Hello");

String str = (String) list.get(0);

System.out.println("String: " + str);

As you can see, we have added a String object to the ArrayList. Since we are the ones who have written the code, we know what type of object the element represents, but, the compiler does not know that. So, when we attempt to retrieve the value from the list, we get back an Object and we have to perform an explicit casting.

list.add(123);

String number = (String) list.get(1);

System.out.println("Number: " + number);

If we add an Integer to the same list and try to fetch the value, we will get a ClassCastException because an Integer object cannot be cast to a String.

By using Generics, we can solve both problems discussed above. Let's see how.

First, we need to use the diamond operator and narrow the type of object held in this list. We need to mention the object type explicitly within the diamond operator. This will enforce a compile-time check, so you no longer have to perform explicit casting. You will also be able to eliminate the ClassCastException.

List<String> list = new ArrayList();

list.add("Hello");

String str = list.get(0); // No need for explicit casting

System.out.println("String: " + str);

list.add(123); // Throws compile-time error

##Naming Conventions for Type Parameters

In the previous example, you saw that the use of List<String> narrowed the type of the object that the list could hold. Check out the following example of a Box class and how it works with different types of data.

public class Box<T> {
    private T value;

    public void setValue(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }

    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.setValue("Hello, world!");
        System.out.println(stringBox.getValue());

        Box<Integer> integerBox = new Box<>();
        integerBox.setValue(123);
        System.out.println(integerBox.getValue());
    }
}

Note how the Box<T> class is declared. Here, the T is a type parameter, indicating that the Box class can work with any object of that type. The same is illustrated in the main method where an instance of Box<String> and Box<Integer> are both allowed to be created, thus ensuring type safety.

As per the official documentation:

By convention, type parameter names are single, uppercase letters.

The most commonly used type parameter names are:

E - Element (used extensively by the Java Collections Framework)
K - Key
N - Number
T - Type
V - Value
S,U,V etc. - 2nd, 3rd, 4th types

Let's take a look at how we can write a generic method. Below is the convention:

public static <T> void printArray(T[] inputArr) {
    for (T element : inputArr) {
        System.out.print(element + " ");
    }
    System.out.println();
}

Here, we take an array of any type and print its elements. Note that you need to specify the generic type parameter T in the angle brackets <> before the return type of the method. The method body iterates over the array that we have passed as a parameter, of any type T, and prints each element.

 public static void main(String[] args) {
        // Create different arrays of type Integer, Double and Character
        Integer[] intArr = {1, 2, 3, 4, 5};
        Double[] doubleArr = {1.1, 2.2, 3.3, 4.4, 5.5};
        Character[] charArr = {'H', 'E', 'L', 'L', 'O'};

        System.out.println("Integer array contains:");
        printArray(intArr);   // pass an Integer array

        System.out.println("Double array contains:");
        printArray(doubleArr);   // pass a Double array

        System.out.println("Character array contains:");
        printArray(charArr);   // pass a Character array
    }

We can call this generic method by passing different types of arrays (Integer, Double, Character) and you will see that your program will print the elements of each of these arrays.

##Restrictions on Generics

In Generics, we use bounds to restrict the types that a generic class, interface, or method can accept. There are two types:

####1. Upper Bounds This is used to restrict the generic type to an upper limit. To define an upper bound, you use the extends keyword. By specifying an upper bound, you ensure that the class, interface, or method accepts the specified type and all of its subclasses.

The syntax would be as follows: <T extends SuperClass>.

If you consider the same Box class that we used previously, it can be modified as below:

class Box<T extends Number> {
    private T value;

    public void setValue(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

In this example, T can be any type that extends Number, such as Integer, Double, or Float.

####2. Lower Bounds This is used to restrict the generic type to a lower limit. To define a lower bound, you use the super keyword. By specifying a lower bound, you ensure that the class, interface, or method accepts the specified type and all of its superclasses.

The syntax would be as follows: <T super SubClass>.

To illustrate the use of lower bounds, let us take a look at the following example:

public static void printList(List<? super Integer> list) {
    for (Object element : list) {
        System.out.print(element + " ");
    }
    System.out.println();
}

The usage of a lower bound <? super Integer> ensures that you can pass the specified type and all of its superclasses, which in this case would be a list of Integer, Number, or Object to the method printList.

##What are Wildcards?

The ? that you saw in the previous example is called a Wildcard. You can use them to refer to an unknown type.

You can use a wildcard with an upper bound, in which case it would look something like this: <? extends Number>. It can also be used with a lower bound, such as <? super Integer>.

##Type Erasure

The generic type that we use in our class, interface, or method is only available at compile time and it is removed at run-time. This is done to ensure backward compatibility, as the older versions of Java (before Java 1.5) do not support it.

The compiler makes use of the generic type information that is available to it to ensure type safety. In the process of type erasure:

• If the type is unbounded, then the parameters get replaced with their bounds or Object type
• If the type is bounded, then the parameters get replaced by the first bound, and the generic type information will be removed after compilation

If we take a look at the Box class example:

public class Box<T> {
    private T value;
    //getters and setters
 }

The above code will become this:

public class Box {
    private Object value;
    //getters and setters
 }

##Conclusion

In this article, we explored the concept of generics in Java and how you can use them, with some basic examples. Understanding and using generics enhances type safety in your program. They also eliminate the need for explicit casting and make your code reusable and maintainable.

Let's connect on LinkedIn.

SOLID principles are a set of five design principles used in object-oriented programming. Adhering to these principles will help you develop robust software. They will make your code more efficient, readable, and maintainable.

SOLID is an acronym that stands for:

• Single Responsibility Principle
• Open/Closed Principle
• Liskov Substitution Principle
• Interface Segregation Principle
• Dependency Inversion Principle

Single Responsibility Principle

The single responsibilty principle states that every class must have a single, focused responsibility, a single reason to change.

public class Employee{
  public String getDesignation(int employeeID){ // }
  public void updateSalary(int employeeID){ // }
  public void sendMail(){ // }
}

In the above example, the Employee class has a few employee class-specific behaviors like getDesignation & updateSalary.

Additionally, it also has another method named sendMail which deviates from the responsibility of the Employee class.

This behavior is not specific to this class, and having it violates the single responsibility principle. To overcome this, you can move the sendMail method to a separate class.

Here's how:

public class Employee{
  public String getDesignation(int employeeID){ // }
  public void updateSalary(int employeeID){ // }
}

public class NotificationService {
    public void sendMail() { // }
}

Open/Closed Principle

According to the open/closed priniciple, components must be open for extension, but, closed for modification. To understand this principle, let us take an example of a class that calculates the area of a shape.

public class AreaCalculator(){
  public double area(Shape shape){
    double areaOfShape;
    if(shape instanceof Square){
        // calculate the area of Square
    } else if(shape instanceof Circle){
        // calculate the area of Circle
    }
    return areaOfShape;
  }

The problem with the above example is that if there is a new instance of type Shape for which you need to calculate the area in the future, you have to modify the above class by adding another conditional else-if block. You will end up doing this for every new object of the Shape type.

To overcome this, you can create an interface and have each Shape implement this interface. Then, each class can provide its own implementation for calculating the area. This will make your program easily extensible in the future.

interface IAreaCalculator(){
  double area();
}

class Square implements IAreaCalculator{
  @Override
  public double area(){
    System.out.println("Calculating area for Square");
    return 0.0;
   }
}

class Circle implements IAreaCalculator{
  @Override
  public double area(){
    System.out.println("Calculating area for Circle");
    return 0.0;
   }
}

Liskov Substitution Principle

The Liskov substitution principle states that you must be able to replace a superclass object with a subclass object without affecting the correctness of the program.

abstract class Bird{
   abstract void fly();
}

class Eagle extends Bird {
   @Override
   public void fly() { // some implementation }
}

class Ostrich extends Bird {
   @Override
   public void fly() { // dummy implementation }
}

In the above example, the Eagle class and the Ostrich class both extend the Bird class and override the fly() method. However, the Ostrich class is forced to provide a dummy implementation because it cannot fly, and therefore it does not behave the same way if we replace the Bird class object with it.

This violates the Liskov substitution principle. To address this, we can create a separate class for birds that can fly and have the Eagle extend it, while other birds can extend a different class, which will not include any fly behavior.

abstract class FlyingBird{
   abstract void fly();
}

abstract class NonFlyingBird{
   abstract void doSomething();
}

class Eagle extends FlyingBird {
   @Override
   public void fly() { // some implementation }
}

class Ostrich extends NonFlyingBird {
   @Override
   public void doSomething() { // some implementation }
}

Interface Segregation Principle

According to the interface segregation principle, you should build small, focused interfaces that do not force the client to implement behavior they do not need.

A straightforward example would be to have an interface that calculates both the area and volume of a shape.

interface IShapeAreaCalculator(){
  double calculateArea();
  double calculateVolume();
}

class Square implements IShapeAreaCalculator{
  double calculateArea(){ // calculate the area }
  double calculateVolume(){ // dummy implementation }
}

The issue with this is that if a Square shape implements this, then it is forced to implement the calculateVolume() method, which it does not need.

On the other hand, a Cube can implement both. To overcome this, we can segregate the interface and have two separate interfaces: one for calculating the area and another for calculating the volume. This will allow individual shapes to decide what to implement.

interface IAreaCalculator {
    double calculateArea();
}

interface IVolumeCalculator {
    double calculateVolume();
}

class Square implements IAreaCalculator {
    @Override
    public double calculateArea() { // calculate the area }
}

class Cube implements IAreaCalculator, IVolumeCalculator {
    @Override
    public double calculateArea() { // calculate the area }

    @Override
    public double calculateVolume() {// calculate the volume }
}

Dependency Inversion Principle

In the dependency inversion principle, high-level modules should not depend on low-level modules. In other words, you must follow abstraction and ensure loose coupling

public interface Notification {
    void notify();
}

public class EmailNotification implements Notification {
    public void notify() {
        System.out.println("Sending notification via email");
    }
}

public class Employee {
    private EmailNotification emailNotification; 
    public Employee(EmailNotification emailNotification) {
        this.emailNotification = emailNotification;
    }
    public void notifyUser() {
        emailNotification.notify();
    }
}

In the given example, the Employee class depends directly on the EmailNotification class, which is a low-level module. This violates the dependency inversion principle.

public interface Notification{
  public void notify();
}

public class Employee{
  private Notification notification;
  public Employee(Notification notification){
      this.notification = notification;
  }
  public void notifyUser(){
    notification.notify();
  }
 }

 public class EmailNotification implements Notification{
    public void notify(){
        //implement notification via email 
    }
 }

 public static void main(String [] args){
    Notification notification = new EmailNotification();
    Employee employee = new Employee(notification);
    employee.notifyUser();
 }

In the above example, we have ensured loose coupling. Employee is not dependent on any concrete implementation, rather, it depends only on the abstraction (notification interface).

If we need to change the notification mode, we can create a new implementation and pass it to the Employee.

Conclusion

In conclusion, we've covered the essence of SOLID principles through straightforward examples in this article.

These principles form the building blocks for developing applications that are highly extensible and reusable.

Let's connect on LinkedIn

Object-oriented programming is one such paradigm, where the code is organized as objects.

It is used to develop desktop and mobile applications or more complex web or enterprise applications.

Using object-oriented programming, you can build modular and scalable software that is easy to maintain.

In this article, you will learn about the principles of object-oriented Programming that lay the foundation for building robust systems.

We will use Java as the programming language for the examples provided below.

What is Object-Oriented Programming?

Object-Oriented Programming is a programming methodology that models real-world entities in the form of objects.

These objects are instances of classes.

A class can be thought of as a blueprint and each class can contain fields, which define the attributes of the object, and methods, which describe the object's behavior. Each class can be developed, tested, and debugged independently.

Now that you have an understanding of the basic definition of object-oriented programming, let us jump right in and learn about its core principles.

There are four core principles, or pillars, in the object-oriented Programming paradigm. They are:

• Abstraction
• Encapsulation
• Inheritance
• Polymorphism

What do they mean? Let us explore further with a simple explanation followed by an example for each of them in the following sections.

What is Abstraction?

Abstraction is defined as the concept of hiding the details of implementation and exposing only the necessary functionalities of the object to the user.

The keywords that you need to keep in mind here are: 'Implementation hiding'.

Abstraction in Java can be achieved through Interfaces and Abstract classes.

abstract class Animal {
    public abstract void makeSomeNoise();
}

class Dog extends Animal {
    public void makeSomeNoise() {
        System.out.println("Bark");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.makeSomeNoise(); // Output - Bark
    }
}

In the above example, abstraction is achieved with the help of an abstract class named Animal.

Here, only the necessary functionality of the class is exposed via the makeSomeNoise() method.

The details of implementation are hidden in the abstract class and they are only provided in the concrete class Dog, which extends the Animal class.

Note that you will learn more about the extends keyword while we discuss Inheritance.

What is Encapsulation?

Encapsulation refers to the concept of encapsulating or wrapping up the member variables (data) and the methods (behavior) of an object into a single unit, such as a class.

The internal information of the object is hidden so that we can prevent unintended modifications and allow only controlled access. The keywords that you need to keep in mind here are: 'Information hiding'.

Encapsulation in Java is achieved through access modifiers. We mark the fields as private and make them accessible via public setter and getter methods.

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("Raj", 30);
        person.display(); // Output - Name: Raj, Age: 30

        person.setName("Kumar");
        person.setAge(25);
        person.display(); // Output - Name: Kumar, Age: 25
    }
}

In the above example, the fields and methods are encapsulated within a class named Person.

You declare the fields name and age as private and provide public setter and getter methods getName(), setName(), getAge(), and setAge() to modify the values as needed.

What is Inheritance?

Inheritance establishes a hierarchical relationship between two classes.

In this concept, one class inherits the fields (properties) and methods (behavior) of another class, while having properties and behavior of its own.

The class that inherits from another is called a subclass, derived class, or child class. The class from which the subclass inherits is known as the superclass, base class, or parent class.

In Java, inheritance is achieved using the extends keyword.

class Animal {
    public void makeSomeNoise(){
        System.out.println("Make some animal noise");
    }
}

class Dog extends Animal {
    public void makeSomeNoise() {
        System.out.println("Bark");
    }
    public void doSomething(){
        System.out.println("Play with ball");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.makeSomeNoise(); // Output - Bark
        myDog.doSomething(); // Output - Play with ball
    }
}

In the above example, the extends keyword indicates that the Dog class is the subclass of the Animal class.

The Dog class inherits the makeSomeNoise() method from the Animal class. This allows the Dog class to reuse the method and provide its own implementation without having to rewrite it completely.

You can also note that the Dog class has its own behavior through the doSomething() method.

Inheritance defines an "IS-A" relationship between the two classes. In our example, Dog IS-A Animal.

Note that Java supports multi-level inheritance. For example, class Labrador inherits from class Dog, which in turn inherits from class Animal. However, it does not support multiple inheritance. That is, a class is not allowed to inherit from two or more parent classes.

What is Polymorphism?

Poly (many), morph (forms).

Polymorphism defines the capability of an object to be represented in different forms.

In Java, polymorphism can be categorized into two types: compile-time polymorphism and runtime polymorphism.

Compile-time polymorphism is achieved through method overloading – multiple methods have the same name but different type or number of parameters.

class MathOperation {
    public int add(int a, int b) {
        return a + b;
    }

    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

public class Main {
    public static void main(String[] args) {
        MathOperation math = new MathOperation();
        System.out.println(math.add(95, 5));       // Output - 100
        System.out.println(math.add(75, 5, 20));   // Output - 100
    }
}

In the above example, we have overloaded the add() method. There are two methods with the same name add but they have different number of parameters.

During compilation, based on the number of parameters passed to the method, the appropriate call is made.

Runtime polymorphism is achieved through method overriding – a subclass has a method with the same name and same set of parameters as that of its superclass method. However, it provides its own implementation of the method.

Here, the method resolution happens at runtime.

class Animal {
    public void makeSomeNoise() {
        System.out.println("Make some animal noise");
    }
}

class Dog extends Animal {
    @Override
    public void makeSomeNoise() {
        System.out.println("Barks");
    }
}

class Cat extends Animal {
    @Override
    public void makeSomeNoise() {
        System.out.println("Meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal; 

        myAnimal = new Dog(); 
        myAnimal.makeSomeNoise(); // Output - Barks

        myAnimal = new Cat(); 
        myAnimal.makeSomeNoise(); // Output - Meows
    }
}

In the above example, the makeSomeNoise() method of the Animal class is overridden by the Dog and Cat subclasses and they provide their own implementation of this method.

During object creation, the Animal variable holds a Dog or Cat object and when the makeSomeNoise() method is called, the appropriate overridden method is called based on the actual object type.

Conclusion

In this article, we explored the fundamental principles of Object-Oriented Programming (OOP).

Familiarity with these concepts is crucial for building robust, maintainable, and scalable software systems.