Design Patterns

Design Pattern
• A design pattern is just a convenient way of reusing object-oriented
(OO) code between projects and programmers. A common pattern in
early literature on programming frameworks is Model-View-
Controller (MVC) for Smalltalk [Krasner and Pope, 1988], which
divides the user interface problem into three parts.
Design Pattern Definitions
1. Design patterns are recurring solutions to design problems you see over and
over.
2. Design patterns constitute a set of rules describing how to accomplish certain
tasks in the realm of software development.
3. Design patterns focus more on reuse of recurring architectural design themes,
while frameworks focus on detailed design... and implementation
4. A pattern addresses a recurring design problem that arises in specific design
situations and presents a solution to it.
5. Patterns identify and specify abstractions the at are above the level of single
classes and instances, or of components.
6. Design patterns are not just about the design of objects; they are
also about interaction between objects. One possible view of
some of these patterns is to consider them as communication
patterns
Design Pattern Continue
• The design patterns divides into three types:
• Creational patterns: create objects for you, rather than your having
to instantiate objects directly. Your program gains more flexibility in
deciding which objects need to be created for a given case.
• Structural patterns: help you compose groups of objects into larger
structures, such as complex user interfaces and accounting data.
• Behavioral patterns: help you to define the communication between
objects in your system and how the flow is controlled in a complex
program.
 Division Of Design pattern

Creational Pattern • Behavioral patterns: • Structural patterns

1. Chain of Responsibility
2. Command
1.Singleton 1.Adapter
3. Interpreter
2.Factory 4. Iterator 2.Bridge
3.Factory Method 5. Mediator 3.Composite
4.Abstract Factory 6. Memento 4.Decorator
7. Observer
5.Builder 5.Flyweight
8. Strategy
6.Prototype 9. Template Method 6.Proxy
7.Object Pool 10.Visitor
11.Null Object
Design Pattern use in Android

Three most common Design Patterns use in Android

1)MVC (Model View Controller)

2)MVP (Model View Presenter)
3)MVVM (Model-View-View Model)
MVC (Model View Control)
1. Data Model, which contains the computational parts of the program
2. View, which presents the user interface
3. Controller, which interacts between the user and the view
4. Each aspect of the problem is a separate object , and each has its
own rules for managing its data.
5. Communication between the user, the graphical user interface
( GUI), and the data should be carefully controlled
Model View Controller for Android

• Controllers are the activities themselves which contain all the business
logic done in the application.

• Models are our entities which describe the components of our apps.

• Views can be done in XML layouts.

 MVP (Model View Presenter)
Most Important Design Patter

• The MVP pattern allows separate the presentation layer from the logic.

• Model-View-Presenter pattern is a perfect fit for android development. Since

the Views role in this pattern are:

 serving as a entry point

 rendering components
 routing user events to the presenter
MVP (Model View Presenter)
Most Important Design Patter in Android
The presenter
The presenter is responsible to act as the middle man between view and model. It retrieves data from
the model and returns it formatted to the view.

The View
The view, usually implemented by an Activity (it may be a Fragment, a View… depending on how the app
is structured), will contain a reference to the presenter.
The only thing that the view will do is calling a method from the presenter every time there is an
interface action (a button click for example).

The model
In an application with a good layered architecture, this model would only be the gateway to the domain
layer or business logic.
Difference B/w MVC & MVP
MVC MVP

UI Presentation Pattern focus on separation of view with Based on MVC (UI Presentation Pattern)
Model

Separation of responsibility between three components: Separation of responsibility between four components:
1.View - responsible for rendering UI 1.View - responsible for rendering UI
elements elements
2.Controller - responsible for responding to 2.View Interface - responsible for loose
view actions coupling between view and model
3.Presenter - responsible for view and model
3.Model - responsible for business behavior
interaction
and state management 4.Model - responsible for business behavior
and state management
Difference B/w MVC & MVP Continue

MVC MVP
Fairly loose coupling Comparatively high degree of loose coupling

Limited unit testing Comparatively high degree of ease of unit testing

Controller is behavior based and multiple views Usually one view has one presenter (1-1 mapping).
can share single controller Multiple presenters would be associated with a
complex view
Identifies which view to update Presenter will update its associated view
The Following Android Classes uses Design
Patterns

1) View Holder uses Singleton Design Pattern

2) Intent uses Factory Design Pattern
3) Adapter uses Adapter Design Pattern
4) Broadcast Receiver uses Observer Design Pattern
5) View uses Composite Design Pattern
6) Media FrameWork uses Façade Design Pattern
Creational Patterns
Singleton Pattern
• Sometimes it's important to have only one instance for a class. For
example, in a system there should be only one window manager (or only a
file system or only a print spooler). Usually singletons are used for
centralized management of internal or external resources and they
provide a global point of access to themselves.

• The singleton pattern is one of the simplest design patterns: it involves

only one class which is responsible to instantiate itself, to make sure it
creates not more than one instance; in the same time it provides a global
point of access to that instance. In this case the same instance can be used
from everywhere, being impossible to invoke directly the constructor each
time.
1st Way 2nd Way
• class Singleton • class Singleton
• {
• {
• private static Singleton instance = new Singleton();
• private static Singleton instance; • private Singleton()
• private Singleton() { } • {
• ...
• public static synchronized Singleton • }
getInstance() • public static synchronized Singleton getInstance()
• { • {
• return instance;
• if (instance == null)
• }
• instance = new Singleton(); • public void doSomething()
• return instance; • {
• } • ...
• public void doSomething() { } • }
• }
• }
Factory Pattern
• When a interface does not know which sub-class of objects initilize it
Factory Pattern example 2
Structural Patterns
Adapter Design Pattern

• The adapter pattern is adapting between classes and objects. Like any
adapter in the real world it is used to be an interface, a bridge
between two objects.

• it's used to identifying a simple way to realize relationships between

entities.

• The main use of this pattern is when a class that you need to use
doesn't meet the requirements of an interface.
Composite Design Pattern
• Composite pattern is used where we need to treat a group of objects
in similar way as a single object. Composite pattern composes objects
in term of a tree structure to represent part as well as whole
hierarchy
• This pattern creates a class contains group of its own objects. This
class provides ways to modify its group of same objects
Behavioral patterns
 Observer Design Pattern
Observer pattern is one of the behavioral design pattern
Observer design pattern is useful when you are interested in the state
of an object and want to get notified whenever there is any change
In observer pattern, the object that watch on the state of another
object are called Observer and the object that is being watched is
called Subject