A static class can have multiple instances, while a singleton class can only have one instance. A static class is a class that is declared as static and can only access static variables and methods. A singleton class is a class that ensures that only one instance of the class exists in the JVM.

The Dependency Injection pattern involves passing objects as dependencies to the objects that require them, while the Service Locator pattern involves a central registry that provides objects when requested. The Dependency Injection pattern provides objects to its client as they are needed, while the Service Locator pattern allows objects to request objects they need from a centralized registry.

The Façade pattern provides a simplified interface to a complex system, while the Mediator pattern provides a way for components of a system to communicate with each other in a loosely coupled manner. Façade is a one-way communication pattern, while Mediator is a two-way communication pattern.

The Facade pattern provides a simplified interface to a complex system, hiding the complexity of the system behind a single interface and making it easier to use

The Repository and Unit of Work patterns are related, as the Unit of Work is responsible for managing the persistence of data changes, while the Repository provides an abstraction over the data access layer. The Repository can use the Unit of Work to persist changes to the data.

Command pattern is a design pattern that converts a request into a standalone object, allowing the client to parametrize objects with different requests, queue a request, or log requests. The pattern involves creating a command class that encapsulates the request as an object, and passes the request to the invoker object. The invoker object then executes the command. This pattern can be useful in situations where you want to decouple the client from the receiver of the request, and where you want to provide a unified interface for undo and redo operations.

The State pattern allows an object to alter its behavior when its internal state changes, while the Strategy pattern allows an object to change its behavior based on the context it is in

A behavioral design pattern that separates an algorithm from an object structure on which it operates. The pattern allows you to define a new operation without changing the classes of the objects on which it operates.

Inversion of Control is a design principle in which the flow of control in a system is inverted. Instead of a system calling components to perform tasks, components are notified when tasks are ready and perform them. This leads to a more flexible and decoupled system, allowing for easier maintenance and testing.

The actor classes used in the Memento pattern are: Originator, Memento, and Caretaker. The Originator class is responsible for creating the memento and restoring its state. The Memento class is responsible for storing the internal state of the Originator. The Caretaker class is responsible for maintaining a list of mementos and providing the Originator with the appropriate memento at the appropriate time.