Flyweight Pattern

Structural Patterns - Flyweight Pattern
The pattern here states about a mechanism by which you can avoid creating a large number of object instances to represent the entire system.
To decide if some part of your program is a candidate for using Flyweights, consider whether it is possible to remove some data from the class and make it extrinsic. If this makes it possible to reduce greatly the number of different class instances your program needs to maintain, this might be a case where Flyweights will help.
The typical example you can see on this in every book will be of folders. The folder with name of each of the company employee on it, so, the attributes of class Folder are: ‘Selected’ , ‘Not Selected’ and the third one is ‘employeeName’. With this methodology, we will have to create 2000 folder class instances for each of the employees. This can be costly, so we can create just two class instances with attributes ‘selected’ and ‘not selected’ and set the employee’s name by a method like:

setNameOnFolder(String name);
This way, the instances of class folder will be shared and you will not have to create multiple instances for each employee.
I was going through this pattern and was trying to find the best suited non-software example. Then, I remembered the talks I had with one of my cousin’s who used to work in a grinding wheel manufacturing company. I am a Chemical Engineer and so, remember the names of chemical compounds. He was telling me that the grinding wheels are used for metal cutting across the industry. Basically the main ingredients for these grinding wheels are Aluminum Oxide (Al2O3) and Silicon Carbide (SiC). These compounds are used in form of grains. For those who remember Chemistry from schools, and for others, just follow the example.

His company manufactures nearly 25000 types of grinding wheels. Now, there is another technicality in this and that is bonding.
There are two types of bondings used to bond the material i.e. Aluminum Oxide and Silicon Carbide together. One is Glass bonding – this is like, the wheel is heated to 1300 degree C and the silicon turns into glass to hold the two materials together. The second type of bonding is Resin bonding, this is when some resins help in holding the materials together. The wheels are in different sizes, have different ratio of materials mixed and have any of these two types of bondings. This decides the strength of the wheel. In all, creating 25,000 types of combinations is a pretty complex looking scenario.

If we consider this from software point of view, we can see that each wheel is of a different type and so, we need to make 25000 classes for taking care of each of the wheel. This of course will be very resource intensive. So, how to avoid this?
Well, we already know a few things and we can see a common pattern in each of the wheels. The common things are as follows:

1. Materials of use – They are always Aluminum Oxide and Silicon Carbide.
2. Each wheel has a bonding.
3. Each wheel has a size.

We can follow one thing, the combination above mentioned three ingredients can give us a large number of instances so, why not take a scenario where only one of these is used in the constructor and rest be passed as method parameters.
Let’s have a look at the code. For every flyweight, there is a factory providing the object instance. Now, naturally wheels are made in a factory so, there is GrindingWheelFactory class which returns the type of wheel needed.

GrindingWheelFactory.java

package structural.flyweight; /** * This factory of wheel is accessed by the client. Everytime, * the client wants a wheel, the software is accessed through this * Factory class. The specifications are passed through the * method parameters and a new wheel is returned. * * User: prashant.satarkar * Date: Apr 8, 2004 * Time: 5:06:13 PM */ public class GrindingWheelFactory {
	/** * The method takes the input parameters and return the appropriate * wheel. * * @return An instance of grinding wheel */ public GrindingWheel getWheel(boolean isGlassBonded) { return new GrindingWheel(isGlassBonded); }
}// End of interface

This class is very important. Let’s have a closer look at the class. It returns a wheel based only on the bonding. As we know that bondings are only of two types, and so, at any point in time, there will be two instances which are negligible as compared to 25000.
The other important class here is of course GrindingWheel. This gets constructed depending on the parameters passed to the method getWheel() of class GrindingWheelFactory. Let’s have a look at the class GrindingWheel.

GrindingWheel.java

package structural.flyweight; /** * The wheel is formed for different ratio of alumina * and silicon carbide, for a different bonding and for * a different size, which depends on the diameter of * the wheel. * * User: prashant.satarkar * Date: Apr 8, 2004 * Time: 5:13:23 PM */ public class GrindingWheel {
	private int ratioAlumina; private int diameter; private boolean isGlassBonded; /** * Default Constructor * */ public GrindingWheel(boolean isGlassBonded) { this. isGlassBonded = isGlassBonded; } . . . .
}// End of class

This class can have other methods getters and setters for diameter, and ratioAlumina, on which the complete wheel is dependent.
In each of the instances of the wheels, we can pass the values of ratio of alumina to silicon carbide as method parameters and also the sizes which can lead to a great number of combinations.
Hence, we can see that by using the flyweight pattern, we can reduce the instances of the class.