Design pattern in android

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
1.Singleton
2.Factory
3.Factory Method
4.Abstract Factory
5.Builder
6.Prototype
7.Object Pool
• Structural patterns
1.Adapter
2.Bridge
3.Composite
4.Decorator
5.Flyweight
6.Proxy
• Behavioral patterns:
1. Chain of Responsibility
2. Command
3. Interpreter
4. Iterator
5. Mediator
6. Memento
7. Observer
8. Strategy
9. Template Method
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
Model
Based on MVC (UI Presentation Pattern)
Separation of responsibility between three components:
1.View - responsible for rendering UI
elements
2.Controller - responsible for responding to
view actions
3.Model - responsible for business behavior
and state management
Separation of responsibility between four components:
1.View - responsible for rendering UI
elements
2.View Interface - responsible for loose
coupling between view and model
3.Presenter - responsible for view and model
interaction
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
can share single controller
Usually one view has one presenter (1-1 mapping).
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

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
• class Singleton
• {
• private static Singleton instance;
• private Singleton() { }
• public static synchronized Singleton
getInstance()
• {
• if (instance == null)
• instance = new Singleton();
• return instance;
• }
• public void doSomething() { }
• }
2nd Way
• class Singleton
• {
• private static Singleton instance = new Singleton();
• private Singleton()
• {
• ...
• }
• public static synchronized Singleton getInstance()
• {
• return instance;
• }
• public void doSomething()
• {
• ...
• }
• }

Factory Pattern
• When a interface does not know which sub-class of objects initilize it

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

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

Design pattern in android

More Related Content

What's hot (20)

Similar to Design pattern in android (20)

Design pattern in android