Low Coupling GRASP Pattern

Read about GRASP Patterns: GRASP Patterns Overview

Problem

How to support low dependency, low change impact, and increase reuse?

Solution

Assign responsibilities so that coupling remains low. Try to avoid one class to have to know about many others.

Key points about low coupling

  • Low dependencies between �artifacts� (classes, modules, components).
  • There shouldn�t be too much of dependency between the modules, even if there is a dependency it should be via the interfaces and should be minimal.
  • Avoid tight-coupling for collaboration between two classes (if one class wants to call the logic of a second class, then first class needs an object of second class it means the first class creates an object of the second class).
  • Strive for loosely coupled design between objects that interact.
  • Inversion Of Control (IoC) / Dependency Injection (DI) - With DI objects are given their dependencies at creation time by some third party (i.e. Java EE CDI, Spring DI�) that coordinates each object in the system. Objects aren�t expected to create or obtain their dependencies�dependencies are injected into the objects that need them. The key benefit of DI�loose coupling.

Implementation


This is an example of loose coupling. In this class, Traveler class is not tightly coupled with Car or Bike implementation. Instead by applying dependency injection mechanism, the loose coupling implementation is achieved to allow start journey with any class which has implemented Vehicle interface.
Step 1: Vehicle interface to allow loose coupling implementation.
interface Vehicle {
 public void move();
}
Step 2: Car class implements Vehicle interface.
class Car implements Vehicle {
 @Override
 public void move() {
  System.out.println("Car is moving");
 }
}
Step 3: Bike class implements Vehicle interface.
class Bike implements Vehicle {
 @Override
 public void move() {
  System.out.println("Bike is moving");
 }
}
Step 4: Now create Traveller class which holds the reference to Vehicle interface.
class Traveler {
 private Vehicle v;
 public Vehicle getV() {
  return v;
 }
 public void setV(Vehicle v) {
     this.v = v;
 }

 public void startJourney() {
  v.move();
 }
}
Step 5: Test class for loose coupling example - Traveler is an example of loose coupling.
public static void main(String[] args) {
 Traveler traveler = new Traveler();
 traveler.setV(new Car()); // Inject Car dependency
 traveler.startJourney(); // start journey by Car
 traveler.setV(new Bike()); // Inject Bike dependency
 traveler.startJourney(); // Start journey by Bike
}

Related GRASP Patterns

Comments

Post a Comment

Popular posts from this blog

Design Patterns used in Hibernate Framework

Image
In this post, let's discuss a different kind of design patterns which are widely used in the Hibernate Framework. Design Patterns denote the best computer programming practices in the object-oriented software development. Hibernate framework has been built by using the following design pattern or standard practices. I list few known design patterns used in Hibernate Framework. Please mention in a comment, if you know any other design patterns used in Hibernate Framework. You can also read my post of  Design Patterns used in Spring Framework Domain Model Pattern The domain model is treated as POJO in Hibernate. The domain model is an object model of the domain that incorporates both behavior and data. Read more about Domain Model Pattern here https://stackoverflow.com/questions/41335249/domain-model-pattern-example Proxy Design Pattern Proxy Pattern for lazy loading - https://docs.jboss.org/hibernate/orm/3.3/reference/en/html/performance.html Proxy Pattern provides a surrogate or pl
Read more

Value List Handler

The  Value List Handler  provides the search and iteration functionality. To perform a search, the Value List Handler uses a  Data Access Object  to execute the query and retrieve the matching results from the database. It is hard to understand this pattern so my suggestion is to go to  source code  section and have a look at code step by step gives you more clarity. This pattern is divided into a number of sections for simplicity like problem, forces, solution etc. Problem (Problem section describes the design issues faced by the developer) You have a remote client that wants to iterate over a large results list. Forces (This section describes Lists the reasons and motivations that affect the problem and the solution. The list of forces highlights the reasons why one might choose to use the pattern and provides a justification for using the pattern) You want to avoid the overhead of using EJB finder methods for large searches. You want to implement a read-only use-case that does
Read more