Flyweight Design Pattern in Java Explained | Structural Design Pattern смотреть онлайн

Flyweight Design Pattern is Structural Design pattern. Flyweight Design pattern concept is explained with example coding in Java.
A flyweight is an object that minimizes memory usage by sharing as much data as possible with other similar objects.
Java String pool is implemented using flyweight design pattern and that is why optimized for memory usage.

Flyweight Design pattern is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory. Often some parts of the object state can be shared, and it is common practice to hold them in external data structures and pass them to the objects temporarily when they are used.

Classic example usage of the flyweight pattern in java is the data structures for graphical representation of characters in a word processor.



It might be desirable to have, for each character in a document, a glyph object containing its font outline, font metrics, and other formatting data, but this would amount to hundreds or thousands of bytes for each character.



Instead, for every character there might be a reference to a flyweight glyph object shared by every instance of the same character in the document; only the position of each character (in the document and/or the page) would need to be stored internally.

Another example is the string interning. The Flyweight design pattern is one of the twenty-three well-known GoF design patterns that describe how to solve recurring design problems to design flexible and reusable object-oriented software, that is, objects that are easier to implement, change, test, and reuse.

What problems can the Flyweight design pattern solve?
• Large numbers of objects should be supported efficiently.
• Creating large numbers of objects should be avoided.

When representing large text documents, for example, creating an object for each character in the document would result in a huge amount of objects that couldn't be processed efficiently.
What solution does the Flyweight design pattern describe?

Define Flyweight objects that
• store intrinsic (invariant) state that can be shared and
• provide an interface through which extrinsic (variant) state can be passed in.

This enables clients to (1) reuse (share) Flyweight objects instead of creating a new object each time and (2) pass in the extrinsic state when they invoke a Flyweight operation. This greatly reduces the number of physically created objects.



The intrinsic state is invariant (context-independent) and therefore can be shared (for example, the code of character 'A' in a given character set).The extrinsic state is a variant (context-dependent) and therefore can not be shared and must be passed in (for example, the position of character 'A' in a text document).


This video covers above Example explaining Flyweight design pattern in Java



—————————— Like, Share, Support, Subscribe ?? —————————

✔ FUNDOTECH - https://www.youtube.com/channel/UC20UQGc_nSoen6lCRMpLQYA
✔ FACEBOOK - https://www.facebook.com/JagrukIndian
✔ TWITTER - https://twitter.com/kunal_saxena
✔ INSTAGRAM - https://www.instagram.com/thejagrukindian/
✔ LINKEDIN - https://www.linkedin.com/in/kunalsaxena/
✔ TECHIE KUNAL BLOG - https://techiekunal.blogspot.com

—————————— Recommended Playlist ——————————

AWS
https://www.youtube.com/playlist?list=PL6xaYiRPflAvO7Y1wfQRQnuY2_1gRX9dU

Java
https://www.youtube.com/playlist?list=PL6xaYiRPflAsw3knfUY4iajm5bTlDUixs

How Tos
https://www.youtube.com/playlist?list=PL6xaYiRPflAvHf4KE8g-41TT0g2hxy1tp

Design Pattern
https://www.youtube.com/playlist?list=PL6xaYiRPflAuUS5tXZdS-b2eazy5JkV48

Resume Building Series
https://www.youtube.com/playlist?list=PL6xaYiRPflAur4xi5lcPzkiemT_KhULiB