What are some examples of coupling in code?

What are some examples of coupling in code?

Coupling in code refers to the degree of interdependence between software modules. High coupling means modules are closely linked, while low coupling indicates they are more independent. Examples include: 1. Tight Coupling: A class directly instantiates another class. 2. Loose Coupling: Using interfaces or abstract classes to interact with other classes. 3. Event-Driven Coupling: Components communicate through events, reducing direct dependencies.

Can you explain tight coupling with a code example?

Sure! Here's a simple example of tight coupling in Java:

class Engine {
    public void start() {
        System.out.println("Engine starting...");
    }
}

class Car {
    private Engine engine = new Engine(); // Tight coupling

    public void startCar() {
        engine.start();
    }
}

In this example, the Car class is tightly coupled to the Engine class because it directly creates an instance of Engine.

What about loose coupling? Can you show me that too?

Absolutely! Here's an example of loose coupling using interfaces in Java:

interface Engine {
    void start();
}

class V8Engine implements Engine {
    public void start() {
        System.out.println("V8 Engine starting...");
    }
}

class Car {
    private Engine engine;

    public Car(Engine engine) { // Loose coupling
        this.engine = engine;
    }

    public void startCar() {
        engine.start();
    }
}

// Usage
Engine myEngine = new V8Engine();
Car myCar = new Car(myEngine);
myCar.startCar();

In this case, the Car class is loosely coupled to the Engine interface, allowing for different engine implementations.

What are the benefits of loose coupling?

Loose coupling offers several benefits, including:

1. Flexibility: You can easily swap out implementations without changing the dependent code.
2. Maintainability: Changes in one module have minimal impact on others, making the code easier to maintain.
3. Testability: It’s easier to test components in isolation, leading to better unit tests.