Sample Code Before public class DatabaseConnection { private static DatabaseConnection instance; private DatabaseConnection() {} public static DatabaseConnection getInstance() { if (instance == null) { instance = new DatabaseConnection(); } return instance; } public void connect() { } } public class Service { public void performTask() { DatabaseConnection connection = DatabaseConnection.getInstance(); connection.connect(); } } After public class DatabaseConnection { // 1. Identify the singleton public void connect() { } } public class Service { // 2. Locate all references to its getInstance() method. private DatabaseConnection connection; // 3. Refactor the singleton to a standard class. public Service(DatabaseConnection connection) { // 4. Inject it as a dependency. this.connection = connection; } public void performTask() { connection.connect(); } } DatabaseConnection connection = new DatabaseConnection(); // You can also mock the connection in your tests Service service = new Service(connection); service.performTask(); Type

[x] Semi-Automatic

Safety

This refactoring is safe when you update all references to the singleton and handle its dependencies correctly.

\ Testing each step ensures that no references to the singleton are missed.

Why Is the Code Better?

Refactoring away from a singleton makes the code more modular, testable, and less prone to issues caused by the global state.

Injecting dependencies allows you to easily replace DatabaseConnection with a mock or different implementation in testing and other contexts.