You are currently viewing Strategy Pattern with Java Example

Strategy Pattern with Java Example


The Strategy Pattern is a behavioral design pattern that allows defining a family of algorithms, encapsulating each one, and making them interchangeable. In this tutorial, we’ll explore the Strategy Pattern using a duck behavior example in Java.

Understanding the Strategy Pattern

The Strategy Pattern consists of three main components:

  1. Strategy: This is an interface defining a set of algorithms. The strategies are interchangeable and encapsulate the algorithms’ behavior.
  2. Concrete Strategies: These are the implementations of the Strategy interface, each representing a specific algorithm.
  3. Context: This is a class that uses the Strategy interface to perform the desired behavior. The context allows switching between different strategies dynamically.

Example: Duck Behavior

Consider a scenario where we have different types of ducks with different behaviors, such as flying and quacking. We want to model this behavior using the Strategy Pattern.

Step 1: Define the Strategy Interface

First, we define the FlyBehavior and QuackBehavior interfaces representing the flying and quacking behaviors, respectively.

Step 2: Implement Concrete Strategies

Next, we implement concrete strategies for flying and quacking behaviors.

Step 3: Create a Context Class

Now, we create a Duck class which acts as the context and utilizes the flying and quacking behaviors.

Step 4: Implement Concrete Duck Types

Finally, we create concrete duck types that extend the Duck class and specify their display.

Step 5: Use the Duck Objects

Now, we can create duck objects and observe their behaviors.


I'm a Mallard duck
Flying with wings
I'm a Rubber duck
Unable to fly


The Strategy Pattern provides a flexible way to define a family of algorithms, encapsulate each one, and make them interchangeable. In this tutorial, we used the Strategy Pattern to model different behaviors of ducks in a Java application. This pattern allows us to add new behaviors easily and facilitates code reuse.

Leave a Reply