Explain the Chain of Responsibility design pattern and provide an example of its usage.

The Chain of Responsibility design pattern is a behavioral design pattern that allows an object to pass a request along a chain of potential handlers until the request is handled or reaches the end of the chain. This pattern decouples the sender of the request from its receivers, giving multiple objects the opportunity to handle the request independently.

The main components of the Chain of Responsibility pattern are:
1. Handler: This is an abstract class or interface that defines the common interface for all the concrete handlers. It contains a reference to the next handler in the chain and provides a method to handle the request.
2. ConcreteHandler: These are the actual handlers that implement the Handler interface. Each concrete handler decides whether to handle the request or pass it to the next handler in the chain.
3. Client: The client is responsible for creating the chain of handlers and initiating the request.

Here is an example to illustrate the usage of the Chain of Responsibility pattern in a real-world scenario:

Let's consider a customer support system where customer queries are handled by different levels of support representatives. The levels include Level 1, Level 2, and Level 3 support. Each level has a specific set of responsibilities and can handle certain types of queries.

We can create a chain of responsibility where each level of support represents a handler. The Level 1 support handler will handle basic queries, such as password resets or general information. If the Level 1 support handler cannot handle the query, it will pass it to the Level 2 support handler. The Level 2 support handler can handle more complex queries, such as technical issues or software bugs. If the Level 2 support handler cannot handle the query, it will pass it to the Level 3 support handler, which can handle critical issues or escalate the query to higher management if necessary.

In this example, the client (customer support system) creates the chain of handlers and passes the customer query to the Level 1 support handler. If the Level 1 support handler cannot handle the query, it passes it to the Level 2 support handler, and so on until the query is handled or reaches the end of the chain.

This design pattern allows for flexibility and scalability in handling customer queries. New levels of support can be added easily by extending the handler interface and adding a new concrete handler to the chain without affecting the existing code.

Overall, the Chain of Responsibility design pattern provides a way to decouple the sender and receiver of a request, allowing multiple objects to handle the request independently and dynamically.