Adapter pattern is a design pattern that allows objects with incompatible interfaces to work together by converting the interface of one object into an interface expected by the client. This pattern involves creating a wrapper class that implements the target interface and delegates calls to the adaptee object. The adapter acts as a bridge between the adaptee and client, allowing them to work together even if their interfaces are not compatible.

The Command pattern is used to allow sending requests to objects without knowing anything about the operation being requested or the receiver of the request. It provides a way to queue or log requests and acts as a marshal between the sender and the receiver.

The choice between Repository Pattern and "smart" business objects depends on the specific requirements of the project, but in general the Repository Pattern provides better separation of concerns and a common interface for data access.

The State pattern is a design pattern in which an object, called the context, holds a reference to an instance of one of several possible concrete state objects, each of which represents a distinct state of the context and implements a common state interface. The State pattern allows the context's behavior to be altered dynamically by changing its state. The State pattern is used to implement state machines, allowing an object's behavior to be altered as its internal state changes.

A Static class is a class that cannot be instantiated and can only have static members. It is a sealed class, which means it cannot be inherited. A Singleton class is a design pattern that ensures a class has only one instance while providing a global point of access to this instance. It uses a private constructor and a static instance variable to ensure that only one instance can be created. Unlike a Static class, a Singleton class can have both static and instance members.

CQRS and Event Sourcing are separate patterns and can be used independently of each other. However, using Event Sourcing with CQRS can provide benefits in terms of versioning and auditing.

Design Patterns are usually categorized into three types: Creational, Structural, and Behavioral. Creational patterns deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. Structural patterns deal with object composition, creating relationships between objects to form larger structures. Behavioral patterns focus on communication between objects, what goes on between objects and how they operate together.

The Memento pattern is used to store the state of an object so that it can be restored later.

The Strategy design pattern allows an object to change its behavior at runtime, while the State design pattern changes the behavior of an object based on its internal state.

The best way to prevent cloning of a singleton object in Java is by throwing a CloneNotSupportedException in the clone method. This will make the class not cloneable and prevent other objects from attempting to create a copy of the singleton object.