Breaking News: Grepper is joining You.com. Read the official announcement!

strategy design pattern pros and cons

Add Answer

Anjali Sharma answered on January 4, 2023 Popularity 3/10 Helpfulness 1/10

answer strategy design pattern pros and cons

strategy design pattern pros and cons

Comment

Pros:

Prevents the conditional statements. (switch, if, else…)

The algorithms are loosely coupled with the context entity. They can be changed/replaced without changing the context entity.

Very easy extendable.

Cons:

Clients must know existence of different strategies and a client must understand how the Strategies differ

It increases the number of objects in the application.

// The strategy interface declares operations common to all
// supported versions of some algorithm. The context uses this
// interface to call the algorithm defined by the concrete
// strategies.
interface Strategy is
    method execute(a, b)

// Concrete strategies implement the algorithm while following
// the base strategy interface. The interface makes them
// interchangeable in the context.
class ConcreteStrategyAdd implements Strategy is
    method execute(a, b) is
        return a + b

class ConcreteStrategySubtract implements Strategy is
    method execute(a, b) is
        return a - b

class ConcreteStrategyMultiply implements Strategy is
    method execute(a, b) is
        return a * b

// The context defines the interface of interest to clients.
class Context is
    // The context maintains a reference to one of the strategy
    // objects. The context doesn't know the concrete class of a
    // strategy. It should work with all strategies via the
    // strategy interface.
    private strategy: Strategy

    // Usually the context accepts a strategy through the
    // constructor, and also provides a setter so that the
    // strategy can be switched at runtime.
    method setStrategy(Strategy strategy) is
        this.strategy = strategy

    // The context delegates some work to the strategy object
    // instead of implementing multiple versions of the
    // algorithm on its own.
    method executeStrategy(int a, int b) is
        return strategy.execute(a, b)


// The client code picks a concrete strategy and passes it to
// the context. The client should be aware of the differences
// between strategies in order to make the right choice.
class ExampleApplication is
    method main() is
        Create context object.

        Read first number.
        Read last number.
        Read the desired action from user input.

        if (action == addition) then
            context.setStrategy(new ConcreteStrategyAdd())

        if (action == subtraction) then
            context.setStrategy(new ConcreteStrategySubtract())

        if (action == multiplication) then
            context.setStrategy(new ConcreteStrategyMultiply())

        result = context.executeStrategy(First number, Second number)

        Print result.

https://refactoring.guru/design-patterns/strategy

Popularity 3/10 Helpfulness 1/10 Language javascript

Source: Grepper

Tags: cons javascript

Link to this answer
Share Copy Link

Contributed on Jan 04 2023

Anjali Sharma

0 Answers Avg Quality 2/10

strategy design pattern pros and cons

Contents

More Related Answers

strategy design pattern pros and cons

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.