IoC stands for "Inversion of Control", a principle in software engineering where the control of objects or portions of a program is transferred to a framework or container. This concept is fundamental to achieving loose coupling in object-oriented design, which makes applications more modular, flexible, and easier to maintain.
Key Concepts of Inversion of Control : 

How IoC Works:

•   Without IoC.

public class Car { private Engine engine; public Car() { this.engine = new Engine(); // Car class is responsible for creating the Engine instance } }

•  With IoC (Dependency Injection).

public class Car { private Engine engine; public Car(Engine engine) { // Engine instance is injected into Car class this.engine = engine; } }

In the example above, with IoC, the `Car` class does not create the `Engine` instance itself. Instead, it receives it from an external source (typically an IoC container).
Benefits of IoC:

Decoupling: Reduces the dependency between components, making the system more modular. Testability: Easier to test components in isolation since dependencies can be easily mocked or stubbed. Flexibility: Easier to swap out implementations of dependencies without modifying the dependent class. 

 Maintainability: Simplifies code management and maintenance by following the single responsibility principle. 

IoC Containers: IoC containers are frameworks that manage the creation and injection of dependencies. Some popular IoC containers are:
Spring (Java): Provides comprehensive support for dependency injection and IoC. 

PicoContainer (Java): Lightweight and simple to use. 

Unity (C#): A dependency injection container from Microsoft. 

Autofac (C#): A popular IoC container for .NET applications.

 
Example in Spring Framework:

Spring Framework is a well-known example of an IoC container. Here’s how dependency injection is typically configured in a Spring application:

 
XML Configuration:

<bean id="engine" class="com.example.Engine"/> <bean id="car" class="com.example.Car"> <constructor-arg ref="engine"/> </bean>

@Configuration public class AppConfig { @Bean public Engine engine() { return new Engine(); } @Bean public Car car() { return new Car(engine()); } }

@Component public class Engine { // Engine properties and methods } @Component public class Car { private final Engine engine; @Autowired public Car(Engine engine) { this.engine = engine; } }

In these examples, the Spring container manages the lifecycle and injection of the `Engine` dependency into the `Car` class. In summary, IoC is a design principle that helps to create flexible, maintainable, and testable software systems by inverting the control of dependency management. Dependency injection is the most common pattern used to implement IoC, and it is supported by various frameworks and containers across different programming languages.