GRASP consist of guidelines for assigning responsibility to classes and objects in object-oriented design. It is not related to the SOLID design principle.

SOLID is an acronym for first five design principles intended to make software designs more understandable, flexible and maintainable.

Design pattern is a general reusable solution to a commonly occurring problem in software design.

Design patterns were originally grouped into the categories: creational patterns, structural patterns, and behavioral patterns.

Creational Pattern

It deals with mechanism how the objects should be created in a specific situation.

Popular creational patterns are

• Abstract factory pattern, which provides an interface for creating related or dependent objects without specifying the objects’ concrete classes.
• Builder pattern, which separates the construction of a complex object from its representation so that the same construction process can create different representations.
• Factory method pattern, which allows a class to defer instantiation to subclasses.
• Prototype pattern, which specifies the kind of object to create using a prototypical instance, and creates new objects by cloning this prototype.
• Singleton pattern, which ensures that a class only has one instance, and provides a global point of access to it.

Structural Pattern

Structural patterns makes the design easy by identifying a simple way to realize relations among entities/classes.

Popular structural patterns are

• Adapter pattern: ‘adapts’ one interface for a class into one that a client expects.
• Bridge pattern: decouple an abstraction from its implementation so that the two can vary independently .
• Composite pattern: a tree structure of objects where every object has the same interface.
• Decorator pattern: add additional functionality to a class at runtime where subclassing would result in an exponential rise of new classes.
• Facade pattern: create a simplified interface of an existing interface to ease usage for common tasks.
• Flyweight pattern: a large quantity of objects share a common properties object to save space.
• Marker pattern: an empty interface to associate metadata with a class.
• Pipes and filters: a chain of processes where the output of each process is the input of the next.
• Proxy pattern: a class functioning as an interface to another thing.

Behavioral Pattern

Behavioral design patterns deal with how objects will be carrying out communication with each other.

Popular behavioral patters are

• Blackboard design pattern: provides a computational framework for the design and implementation of systems that integrate large and diverse specialized modules, and implement complex, non-deterministic control strategies.
• Chain of responsibility pattern: Command objects are handled or passed on to other objects by logic-containing processing objects.
• Command pattern: Command objects encapsulate an action and its parameters.
• Interpreter pattern: Implement a specialized computer language to rapidly solve a specific set of problems.
• Iterator pattern: Iterators are used to access the elements of an aggregate object sequentially without exposing its underlying representation.
• Mediator pattern: Provides a unified interface to a set of interfaces in a subsystem.
• Memento pattern: Provides the ability to restore an object to its previous state (rollback).
• Null object pattern: Designed to act as a default value of an object
• Observer pattern: a.k.a. Publish/Subscribe or Event Listener. Objects register to observe an event that may be raised by another object.
• Scheduled-task pattern: A task is scheduled to be performed at a particular interval or clock time (used in real-time computing).
• Single-serving visitor pattern: Optimise the implementation of a visitor that is allocated, used only once, and then deleted.
• Specification pattern: Recombinable business logic in a boolean fashion.
• State pattern: A clean way for an object to partially change its type at runtime.
• Strategy pattern: Algorithms can be selected on the fly, using composition.
• Template method pattern: Describes the program skeleton of a program; algorithms can be selected on the fly, using inheritance.
• Visitor pattern: A way to separate an algorithm from an object.