// Tutorial //

Flyweight Design Pattern in Java

Published on August 3, 2022
Default avatar
By Pankaj
Developer and author at DigitalOcean.
Flyweight Design Pattern in Java

While we believe that this content benefits our community, we have not yet thoroughly reviewed it. If you have any suggestions for improvements, please let us know by clicking the “report an issue“ button at the bottom of the tutorial.

Today we will look into Flyweight design pattern.

Flyweight Design Pattern

According to GoF, flyweight design pattern intent is:

Use sharing to support large numbers of fine-grained objects efficiently

Flyweight design pattern is a Structural design pattern like Facade pattern, Adapter Pattern and Decorator pattern. Flyweight design pattern is used when we need to create a lot of Objects of a class. Since every object consumes memory space that can be crucial for low memory devices, such as mobile devices or embedded systems, flyweight design pattern can be applied to reduce the load on memory by sharing objects. Before we apply flyweight design pattern, we need to consider following factors:

  • The number of Objects to be created by application should be huge.
  • The object creation is heavy on memory and it can be time consuming too.
  • The object properties can be divided into intrinsic and extrinsic properties, extrinsic properties of an Object should be defined by the client program.

To apply flyweight pattern, we need to divide Object property into intrinsic and extrinsic properties. Intrinsic properties make the Object unique whereas extrinsic properties are set by client code and used to perform different operations. For example, an Object Circle can have extrinsic properties such as color and width. For applying flyweight pattern, we need to create a Flyweight factory that returns the shared objects. For our example, lets say we need to create a drawing with lines and Ovals. So we will have an interface Shape and its concrete implementations as Line and Oval. Oval class will have intrinsic property to determine whether to fill the Oval with given color or not whereas Line will not have any intrinsic property.

Flyweight Design Pattern Interface and Concrete Classes


package com.journaldev.design.flyweight;

import java.awt.Color;
import java.awt.Graphics;

public interface Shape {

	public void draw(Graphics g, int x, int y, int width, int height,
			Color color);


package com.journaldev.design.flyweight;

import java.awt.Color;
import java.awt.Graphics;

public class Line implements Shape {

	public Line(){
		System.out.println("Creating Line object");
		//adding time delay
		try {
		} catch (InterruptedException e) {
	public void draw(Graphics line, int x1, int y1, int x2, int y2,
			Color color) {
		line.drawLine(x1, y1, x2, y2);



package com.journaldev.design.flyweight;

import java.awt.Color;
import java.awt.Graphics;

public class Oval implements Shape {
	//intrinsic property
	private boolean fill;
	public Oval(boolean f){
		System.out.println("Creating Oval object with fill="+f);
		//adding time delay
		try {
		} catch (InterruptedException e) {
	public void draw(Graphics circle, int x, int y, int width, int height,
			Color color) {
		circle.drawOval(x, y, width, height);
			circle.fillOval(x, y, width, height);


Notice that I have intensionally introduced delay in creating the Object of concrete classes to make the point that flyweight pattern can be used for Objects that takes a lot of time while instantiated.

Flyweight Factory

The flyweight factory will be used by client programs to instantiate the Object, so we need to keep a map of Objects in the factory that should not be accessible by client application. Whenever client program makes a call to get an instance of Object, it should be returned from the HashMap, if not found then create a new Object and put in the Map and then return it. We need to make sure that all the intrinsic properties are considered while creating the Object. Our flyweight factory class looks like below code. ShapeFactory.java

package com.journaldev.design.flyweight;

import java.util.HashMap;

public class ShapeFactory {

	private static final HashMap<ShapeType,Shape> shapes = new HashMap<ShapeType,Shape>();

	public static Shape getShape(ShapeType type) {
		Shape shapeImpl = shapes.get(type);

		if (shapeImpl == null) {
			if (type.equals(ShapeType.OVAL_FILL)) {
				shapeImpl = new Oval(true);
			} else if (type.equals(ShapeType.OVAL_NOFILL)) {
				shapeImpl = new Oval(false);
			} else if (type.equals(ShapeType.LINE)) {
				shapeImpl = new Line();
			shapes.put(type, shapeImpl);
		return shapeImpl;
	public static enum ShapeType{

Notice the use of Java Enum for type safety, Java Composition (shapes map) and Factory pattern in getShape method.

Flyweight Design Pattern Client Example

Below is a sample program that consumes flyweight pattern implementation. DrawingClient.java

package com.journaldev.design.flyweight;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

import com.journaldev.design.flyweight.ShapeFactory.ShapeType;

public class DrawingClient extends JFrame{

	private static final long serialVersionUID = -1350200437285282550L;
	private final int WIDTH;
	private final int HEIGHT;

	private static final ShapeType shapes[] = { ShapeType.LINE, ShapeType.OVAL_FILL,ShapeType.OVAL_NOFILL };
	private static final Color colors[] = { Color.RED, Color.GREEN, Color.YELLOW };
	public DrawingClient(int width, int height){
		Container contentPane = getContentPane();

		JButton startButton = new JButton("Draw");
		final JPanel panel = new JPanel();

		contentPane.add(panel, BorderLayout.CENTER);
		contentPane.add(startButton, BorderLayout.SOUTH);
		setSize(WIDTH, HEIGHT);

		startButton.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent event) {
				Graphics g = panel.getGraphics();
				for (int i = 0; i < 20; ++i) {
					Shape shape = ShapeFactory.getShape(getRandomShape());
					shape.draw(g, getRandomX(), getRandomY(), getRandomWidth(),
							getRandomHeight(), getRandomColor());
	private ShapeType getRandomShape() {
		return shapes[(int) (Math.random() * shapes.length)];

	private int getRandomX() {
		return (int) (Math.random() * WIDTH);

	private int getRandomY() {
		return (int) (Math.random() * HEIGHT);

	private int getRandomWidth() {
		return (int) (Math.random() * (WIDTH / 10));

	private int getRandomHeight() {
		return (int) (Math.random() * (HEIGHT / 10));

	private Color getRandomColor() {
		return colors[(int) (Math.random() * colors.length)];

	public static void main(String[] args) {
		DrawingClient drawing = new DrawingClient(500,600);

I have used random number generation to generate different type of Shapes in our frame. If you run above client program, you will notice the delay in creating first Line Object and Oval objects with fill as true and false. After that the program executes quickly since its using the shared objects. After clicking “Draw” button multiple times, the frame looks like below image. flyweight design pattern And you will see following output in command line confirming that Objects are shared.

Creating Line object
Creating Oval object with fill=true
Creating Oval object with fill=false

Thats all for flyweight pattern, we will look into more design patterns in future posts. If you liked it, please share your thoughts in comments section and share it with others too.

Flyweight Design Pattern Example in JDK

All the wrapper classes valueOf() method uses cached objects showing use of Flyweight design pattern. The best example is Java String class String Pool implementation.

Flyweight Design Pattern Important Points

  1. In our example, the client code is not forced to create object using Flyweight factory but we can force that to make sure client code uses flyweight pattern implementation but its a complete design decision for particular application.
  2. Flyweight pattern introduces complexity and if number of shared objects are huge then there is a trade of between memory and time, so we need to use it judiciously based on our requirements.
  3. Flyweight pattern implementation is not useful when the number of intrinsic properties of Object is huge, making implementation of Factory class complex.

That’s all for Flyweight design pattern in java.

If you’ve enjoyed this tutorial and our broader community, consider checking out our DigitalOcean products which can also help you achieve your development goals.

Learn more here

About the authors
Default avatar


Developer and author at DigitalOcean.

Still looking for an answer?

Was this helpful?

Mr. Pankaj, Thanks for taking time to document all the design patterns and sharing with the online community. Your explanations are clean and examples are simple. Thank you, again.

- John

    Is using a map (HashMap in this example) data structure the only way to implement this pattern?

    - Akshayraj A Kore

      Flyweight is used to create objects mainly then why it is called as structural design pattern?

      - Anupama

        Nice tutorial, but I’m confused about the DrawingClient.java example line 23. What does this syntax mean? private static final ShapeType shapes[] = … Isn’t it suposed to be ShapeType[] shapes = …? Or is it a feature that I’m not aware of? Same applies to the line below. F. J.

        - Philip John

          For multithreading applications, Should I implement a “double conditional” with synchronised blocks as in Singletons, to check the existence of a specific instance before creating a new one in the HashMap?

          - Juan Florez

            so here we are using same object every time, is not cause any problem ?

            - dpk

              I was browsing google for java design pattern, at many websites I found wrong information . thanks Pankaj for nice and detailed information about flyweight Kuladeep Patil Project Lead, Wipro

              - Kuladeep Patil

                dose not it should be object creation pattern ?

                - sagar

                  I like it to show internal structure of java to show how that work and how much we use them efficiently

                  - Rudra

                    Cool example . Thanks

                    - Anil