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

The Singleton design pattern is a creational design pattern that restricts the instantiation of a class to a single object. It ensures that only one instance of the class exists throughout the application and provides a global point of access to that instance.

The Singleton pattern is commonly used in scenarios where there is a need for a single, shared resource or when it is necessary to control the number of instances of a class. It is often used in logging, database connections, thread pools, and caching mechanisms.

To implement the Singleton pattern, the class should have a private constructor to prevent direct instantiation from outside the class. It should also have a static method that provides access to the single instance of the class. This method should create the instance if it doesn't exist, or return the existing instance if it does.

Here is an example of the Singleton pattern in Java:

```java
public class DatabaseConnection {
private static DatabaseConnection instance;
private String connectionString;

private DatabaseConnection() {
// Private constructor to prevent direct instantiation
connectionString = "jdbc:mysql://localhost:3306/mydatabase";
// Additional initialization code
}

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

public void connect() {
// Connect to the database using the connection string
// Additional connection code
}

public void disconnect() {
// Disconnect from the database
// Additional disconnection code
}
}
```

In this example, the `DatabaseConnection` class represents a database connection. The private constructor ensures that the class cannot be instantiated directly. The `getInstance()` method provides access to the single instance of the class. If the instance doesn't exist, it creates a new one; otherwise, it returns the existing instance.

To use the Singleton, you can obtain the instance using the `getInstance()` method and then call the appropriate methods on the instance:

```java
DatabaseConnection connection = DatabaseConnection.getInstance();
connection.connect();
// Perform database operations
connection.disconnect();
```

By using the Singleton pattern, you can ensure that there is only one instance of the `DatabaseConnection` class throughout the application, allowing for efficient resource management and centralized access to the database connection.