GRASP: Assigning Responsibilities in Object-Oriented Design

• A set of software patterns for assigning responsibilities.

• Identifying requirements.
• Creating a domain model.
• Creating a design model
  .
  • Adding attributes and methods to software classes
    .
  • Defining how objects interact
    .

A contract or obligation of a class.

• Knowing about private, encapsulated data.
• Knowing about related objects.
• Knowing about information that can be derived or calculated.
• For example, a Sale is responsible for knowing its total.

• Performing an action itself.
• Initiating behavior in another object.
• Controlling and coordinating activities in other objects.
• For example, a Sale is responsible for creating sale line items.

1. Information Expert
2. Creator
3. Controller
4. Low Coupling
5. High Cohesion
6. Polymorphism
7. Pure Fabrication
8. Indirection
9. Protected Variations

• Divide a system into modules and assign responsibilities among its components.

• Group related functions and assign them to modules (
  separation of concerns
  ).
• Give modules small, simple, well-defined interfaces (
  information hiding
  ).

• Coupling measures
  interdependence
  between modules.
• Cohesion measures how closely
  related
  the elements within a module are.

• A measure of interdependence between classes or modules.
• A highly coupled class depends on many other classes.
• A change to one element can affect other elements connected by dependencies.

• Changes in other classes can affect the class.
• The class is harder to understand on its own.
• It is harder to reuse.

• Type X has an attribute that references a
  Type Y instance
  or Type Y itself.
• Type X has a
  method that references
  a Type Y instance or Type Y itself. For example, the method may use Type Y for a parameter or local variable, or return a Type Y instance.
• Type X is a direct or indirect
  subclass
  of Type Y.
• Type X
  implements
  the Type Y interface.
• Type X
  uses
  the Type Y interface, for example by accepting it as a method parameter.
  • Direct reference
    uses a solid line and means Type X directly references Type Y.
  • Method reference
    uses a dotted line and means a method in Type X references Type Y.
  • Inheritance
    uses a solid line with a hollow arrowhead and means Type X inherits from Type Y.
  • Interface implementation
    uses a dashed line with a hollow arrowhead and means Type X implements the Type Y interface.

A measure of how closely related the elements in a module are.

• Code is easier to understand and maintain.
• Code is easier to reuse.
• Coupling tends to be lower.

Creator helps decide which class should be responsible for

creating instances

of another class.

Information Expert assigns a responsibility to the class that has the

information needed

to carry it out.

Controller helps decide which class should be responsible for

handling user interface events and initiating system operations

.

Low Coupling guides you in

minimizing dependencies between classes

when assigning responsibilities.

High Cohesion helps you assess

how closely related the elements inside a class are

when assigning responsibilities.

Pure Fabrication suggests creating a class to take on a responsibility

when no existing class is a good fit

.

Polymorphism guides you in assigning responsibility for

behavior that varies by object type

.

Indirection guides you in

minimizing direct interaction between classes

.

Protected Variations guides you in

protecting parts of the system from changes elsewhere

.