Flyweight Pattern
-
Upload
hueseyin-ergin -
Category
Technology
-
view
1.971 -
download
0
description
Transcript of Flyweight Pattern
Flyweight Pattern
Structural Pattern
2
Motivation You want to draw a forest of trees! How would you implement this? Millions of tree objects in the program?
Memory constraint What is the optimal solution? Can we implement it so that we create only 1
tree object?
3
Flyweight Pattern That’s where flyweight comes in!
If the objects you create have so much common properties (like trees, only positions are different).
The activity diagram may be like this with only one instance.
Then, we have to store positions somewhere! Client can do this for us.
4
Definition Flyweight pattern is a pattern for sharing
objects, where each instance does not contain its own state but stores it externally.
This allows efficient sharing of objects to save space when there are many instances but only a few different types.
5
Text Document Example You want to hold a text document with so
many customizations as style. Each letter in with a different object? Creating the letter ‘E’, may be already there
before,but with a different style!
So we will have aCharFactory to returnus the already createdinstance OR createsit from scratch!
6
Structure
7
Participants Flyweight
Letter as an abstract class SharedConcreteFlyweight
LetterA UnsharedConcreteFlyweight
Not all flyweights must be shared! Row information for example
FlyweightFactory Creates and manages flyweights (Character
factory) Client
The styles are stored here, also call to factory
8
Intrinsic & Extrinsic States From course slides (7.Quality of Design) B is extrinsic to A if A can be fully defined with
no notion of B E.g., class Dog is extrinsic to class Person
B is intrinsic to A if B captures some characteristics inherent to A E.g., class Date is intrinsic to class Person (by date
of birth) What is with us?
Extrinsic states may be stored in client! Intrinsic states may be stored in flyweight itself!
9
Sequence Diagram
10
Applicability Use flyweight pattern iff:
You will use large number of objects. You want to reduce storage costs. Most of object states can be extrinsic. Many group of objects > Fewer shared objects
with states App doesnot care object identity.
Ex: Drawing lots of circleswith different colors and sizes
11
Consequences Run time costs
Client is responsible for extrinsic states (storing, fetching etc)
Normally they are part of the object. Space saving
Will increase as more flyweights are shared. How much you share, that much you save space!
Factory Flyweight must be created only via factory!
12
Demo Circle Drawing. (ref at the end) We want to draw10000 circles in 6 different
colors. Circles have color in common. (intrinsic state) Position and radius information is given as
extrinsic state. (randomly generated)
13
Implementation Issues Storing extrinsic states can be tricky
An object structure for extrinsic states In text document example, you can store a map of
typographic information in seperate structure, instead of storing the font and style information with each object.
This map can keep track of numbers of characters with same attribute.
Accessing a specific object We have to design the system
according to that need. In drawing tree example,
we just draw and go. We can make the access
with a pointer.
14
Implementation Issues Extrinsic states can be stored but what about
we want to change the intrinsic state of a flyweight? Modify the factory as to create new flyweights
with a different intrinsic state also. Not so efficient, slowly breaking the flyweight
pattern. UnsharedConcreteFlyweight is normally a
totally different object but we can also make them sharable via factory. If they become sharable later, the oldly created
ones should be added to factory.
15
Relation with Other Patterns You can combine Composite pattern with
Flyweight. Each UnsharedConcreteFlyweight may be
component with SharedConcreteFlyweights as children.
In text document:Rows are componentsor UnsharedConcFly.Letters are leafsor SharedConcFly.
16
Relation with Other Patterns – cont’d FlyweightFactory produces flyweights as in Factory Method.
No abstract Creator (but we can) FlyweightFactory is the ConcreteCreator. Flyweight is Product. Subclasses of Flyweight is ConcreteProducts.
It only looks for an already created instance instead of returning new ConcreteProduct() immediately.
17
Relation with Other Patterns – cont’d In State Pattern, you can share states with
Flyweight Pattern. Flyweight is State. SharedConcreteFlyweight is ConcreteState. Client is Context.
With that way, Context can share states if the state is already created. Handle method may
also get extrinsicstate as parameter.
18
Relation with Other Patterns – cont’d The same logic works with the Strategy
Pattern. Strategy can be shared, and algorithm can be run
with only different inputs (extrinsic state). The algorithm itself is the intrinsic state.
Difference is: flyweights can be used in many context but strategy is in one context.
19
Practical Example Strings in Java language.
If you don’t explicitly construct a string and put the value with assignment operator, they will be same.
Actually Java has another method called intern for sharing strings.
20
Thanks
Questions?
21
References GoF Design Patterns Book Definition from: C# design patterns, James
cooper http://www.dofactory.com/Patterns/PatternFlyweig
ht.aspx#_self1
http://fc07.deviantart.net/fs32/f/2008/218/8/7/Pine_forest_by_softwalls.jpg
Oreilly Head First: Design Patterns Book Fry of Futurama for Questions Picture Demo: http://
www.javacamp.org/designPattern/flyweight.html http://javatechniques.com/public/java/docs/basics
/string-equality.html