Scribd
Upload
0 views

StrategyDesignPattern

The Strategy Design Pattern is a behavioral design pattern that enables the definition of interchangeable algorithms that can be selected at runtime. It involves a Context class that uses Strategy objects, an interface for strategies, and concrete implementations of those strategies. This pattern enhances code modularity and flexibility, allowing for easy testing and maintenance.

Uploaded by

newsohel800
Copyright
© © All Rights Reserved
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
0 views

StrategyDesignPattern

The Strategy Design Pattern is a behavioral design pattern that enables the definition of interchangeable algorithms that can be selected at runtime. It involves a Context class that uses Strategy objects, an interface for strategies, and concrete implementations of those strategies. This pattern enhances code modularity and flexibility, allowing for easy testing and maintenance.

Uploaded by

newsohel800
Copyright
© © All Rights Reserved
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 2

Strategy Design Pattern

===================================================================================
=================================

The Strategy Design Pattern is a behavioral design pattern that allows you to
define a family of interchangeable algorithms (i.e., strategies) and make them
interchangeable at runtime. It allows you to encapsulate the behavior of an object
and select it at runtime based on the context of the application.

The Strategy Design Pattern involves the following participants:

Context: This is the class that uses the strategy objects. It maintains a reference
to a Strategy object and uses it to delegate tasks to it.

Strategy: This is the interface that defines the common methods that all concrete
strategies must implement.

Concrete Strategies: These are the concrete classes that implement the Strategy
interface. They provide different implementations of the same behavior.

In Java, you can implement the Strategy Design Pattern as follows:

1.Strategy interface as follows

public interface Strategy {


void execute();
}

2. Concrete stategies as follows

public class ConcreteStrategy1 implements Strategy {


public void execute() {
System.out.println("Executing Concrete Strategy 1");
}
}

public class ConcreteStrategy2 implements Strategy {


public void execute() {
System.out.println("Executing Concrete Strategy 2");
}
}

3.context class to use above strategies

public class Context {


private Strategy strategy;

public Context(Strategy strategy) {


this.strategy = strategy;
}

public void setStrategy(Strategy strategy) {


this.strategy = strategy;
}

public void executeStrategy() {


strategy.execute();
}
}
4.exceute using context class

public class Client {


public static void main(String[] args) {
Context context = new Context(new ConcreteStrategy1());
context.executeStrategy(); // outputs "Executing Concrete Strategy 1"

context.setStrategy(new ConcreteStrategy2());
context.executeStrategy(); // outputs "Executing Concrete Strategy 2"
}
}

In this example, the Strategy Design Pattern allows us to switch between different
algorithms (Concrete Strategies) at runtime, without changing the code of the
Context class. This makes the code more modular and flexible, and allows for easy
testing and maintenance.

You might also like