Design Pattern

Creational Pattern

Abstract Factory – allows the creation of objects without specifying their concrete type
Builder – uses to create complex objects
Factory Method – creates objects without specifying the exact class to create
Prototype – creates a new object from an existing object
Singleton – ensures only one instance of an object is created

Structural Pattern

Adapter – allows for two incompatible classes to work together by wrapping an interface around one of the existing classes.
Bridge – decouples an abstraction so two classes can vary independently.
Composite – takes a group of objects into a single object.
Decorator – allows for an object’s behavior to be extended dynamically at run time.
Facade – provides a simple interface to a more complex underlying object.
Flyweight – reduces the cost of complex object models.
Proxy – provides a placeholder interface to an underlying object to control access, reduce cost, or reduce complexity.

Behavioral Pattern

Chain of Responsibility – delegates commands to a chain of processing objects.
Command – creates objects which encapsulate actions and parameters.
Interpreter – implements a specialized language.
Iterator – accesses the elements of an object sequentially without exposing its underlying representation.
Mediator – allows loose coupling between classes by being the only class that has detailed knowledge of their methods.
Memento – provides the ability to restore an object to its previous state.
Observer – is a publish/subscribe pattern which allows a number of observer objects to see an event.
State – allows an object to alter its behavior when its internal state changes.
Strategy – allows one of a family of algorithms to be selected on-the-fly at run-time.
Template Method – defines the skeleton of an algorithm as an abstract class, allowing its sub-classes to provide concrete behavior.
Visitor – separates an algorithm from an object structure by moving the hierarchy of methods into one object.



Single-responsibility principle
A class should only have a single responsibility, that is, only changes to one part of the software’s specification should be able to affect the specification of the class.

Open–closed principle
“Software entities … should be open for extension, but closed for modification.”

Liskov substitution principle
“Objects in a program should be replaceable with instances of their subtypes without altering the correctness of that program.” See also design by contract.

Interface segregation principle
“Many client-specific interfaces are better than one general-purpose interface.”

Dependency inversion principle
One should “depend upon abstractions, [not] concretions.”

OOP Concepts

Object − objects have states and behaviors.
Class – defines the grouping of data and code, the “type” of an object
Instance – a specific allocation of a class
Message – sent to objects to make them act
Method – a “function” that an object knows how to perform
Local Variables − variables defined inside methods, constructors or blocks
Instance Variables – variables within a class but outside any method (a specific piece of data belonging to an object)
Class Variables − variables declared within a class, outside any method, with the static keyword
Abstraction – show only “relevant” data and “hide” unnecessary details of object from the user
Encapsulation – keep implementation private and seperate from interface
Polymorphism – process objects differently based on their data type, using same interface
Inheritance – hierarchical organization, share code, customize or extend behaviors

Design Pattern

Tutorialspoint Design Patterns in Java Tutorial

Javatpoint Design Patterns in Java Tutorial

DZone Design Patterns for Begineers with Java Examples

HowToDoInJava Design Patterns Tutorials

W3spoint Java Design Patterns

SourceMaking Design Patterns