I am confused between the difference of these states for the Flyweight
pattern.
I am aware that intrinsic
state is the state that is shared and that Extrinsic
is not.
However I do not see the importance that extrinsic
state has within the pattern or within the example below:
public static void main(String[] args) {
// Create the flyweight factory...
EngineFlyweightFactory factory = new EngineFlyweightFactory();
// Create the diagnostic tool
DiagnosticTool tool = new EngineDiagnosticTool();
// Get the flyweights and run diagnostics on them
Engine standard1 = factory.getStandardEngine(1300); //intrinsic
standard1.diagnose(tool); //extrinsic
Engine standard2 = factory.getStandardEngine(1300); //intrinsic
standard2.diagnose(tool); //extrinsic
Engine standard3 = factory.getStandardEngine(1300); //intrinsic
standard3.diagnose(tool); //extrinsic
Engine standard4 = factory.getStandardEngine(1600); //intrinsic
standard4.diagnose(tool); //extrinsic
Engine standard5 = factory.getStandardEngine(1600); //intrinsic
standard5.diagnose(tool); //extrinsic
In reference to the example given in Wikipedia about a text editior. Is the intrinsic state the letter, and its extrinsic state the font, colour etc?
The flyweight pattern is a way to handle a situation where what you're trying to accomplish uses a lot of the same type of object. Rather than create a new instance of an object every time, the flyweight pattern reuses objects, only requiring that you track the differences in their usage. The word processor is the classic example. From your Wikipedia example:
This is an accurate description of how the pattern would be used. Following your intrinsic/extrinsic distinction, the glyph objects would be the intrinsic state and the placement of those objects (e.g. what page, paragraph, and line they appear on) would be the extrinsic state/usage of the object.
From your question, where I think you get confused in the example is as to what can be considered an extrinsic/intrinsic attribute. This is likely because the attributes you describe, font style, font colors, and typeface would all be reused as part of the flyweight pattern and so would be "intrinsic" in the sense that they are part of the flyweight pattern but "extrinsic" in the sense that you would account for their application to specific words of letters. For example, in a word processor you likely would have a set of glyphs for the different typefaces in bold, italic, etc; a collection of available colors could also be applied and reused. The program would then track where these attributes were applied but they would not be pure extrinsic states as you describe above.
As for your code above I am not sure how it fits into the flyweight example without seeing any of the code behind it. But from what I can tell it looks similar to the coffee shop example from the Wikipedia article you linked to. The number, whatever that value represents, is unique to the object that is reused.
You should try to get a copy of the original gang of four book on design patterns. The book goes through the word processor example in great detail and that my help you understand more how the pattern works.