flyweight-pattern

I'm developing a new application where I'll have some windows opened at the same time. I'm currently trying to design the GUI and I'm struggling with two choices: I could use a side navigation panel and using the center of the page to display the content of each panel. These panels would be stored according flyweight pattern and I would just hide/show them when navigation buttons are clicked (in order to save the content as is was when hidden, for example a user registration form). I could use a front page displaying the menu all over it and use popups/new windows to show the content. These

From the chapter on FlyWeight Pattern inside Gang of Four the FlyWeight pattern is applicable when most object state can be made extrinsic . What does extrinsic state mean ? I get the feeling that this pattern is used for sharing of objects . If objects are to be shared , then how can that object even have any state at all ? Whatever the specific wording in that bulleted list, it is important to understand the message: Flyweight applies to the case where an important part of data can be shared among many objects because it is immutable. The example with font faces makes this quite clear; an

As far as I know the object pool is a creational pattern and the flyweight is a structural pattern, but actually I can´t see very much difference between the two. Could someone please explain to me the difference and when each could be useful in an implementation? One difference in that flyweights are commonly immutable instances, while resources acquired from the pool usually are mutable. So you create flyweights to avoid the cost of repeatedly create multiple instances of objects containing the same state (because they are all the same, you just create only one and reuse it throughout all

Does the implementation of Java's String memory pool follows flyweight pattern? Why I have this doubt is, I see that there is no extrinsic state involved in Intern. In GoF I read that there should be a right balance between intrinsic and extrinsic state. But in intern everything is intrinsic. Or shall we say there is no strict rule with respect to attributes and just sharing objects to reduce memory is sufficient to call it a flyweight. Please help me understand. Yes the String.intern() implementation follows the flyweight pattern. As the javadoc says Returns a canonical representation for the

If you have two instances of a String, and they are equal, in Java they will share the same memory. How is this implemented under the hood? EDIT: My application uses a large number of String objects, many of which are identical. What is the best way to make use of Java String constant pool, as to avoid creating custom flyweight implementation? Look at the source code of java.lang.String (the source for entire java api is part of the JDK). To summarize: A String wraps a subsequence of a char[] . That backing char[] is never modified. This is accomplished by neither leaking nor capturing this