Jump to Java - In computer programming, the strategy pattern is a behavioral software design pattern that enables selecting an algorithm at runtime. Design Patterns Strategy Patterns - Learning java design patterns in simple and easy steps: A beginner's tutorial containing complete knowledge about an java. Strategy pattern in Java. Code example with detailed comments and explanation. Strategy is a behavioral design pattern that turns a set of behaviors into objects.


Author: Admin
Country: Haiti
Language: English
Genre: Education
Published: 5 February 2014
Pages: 52
PDF File Size: 41.52 Mb
ePub File Size: 38.34 Mb
ISBN: 770-5-62949-206-5
Downloads: 74803
Price: Free
Uploader: Admin


  • Design Patterns Strategy Pattern
  • Strategy Pattern - Web Tutorials -
  • Design Patterns - Strategy Pattern
  • Strategy Pattern Tutorial with Java Examples
  • Navigation menu
  • Java: The Strategy Pattern

It declares a checkTemperature method. The checkTemperature method is implemented so that if the temperature is between 50 and 90, it returns true.

Strategy Design Pattern in Java

Otherwise it returns false. If the temperature is 32 or less, the checkTemperature method returns true.

The purpose of the Strategy strategy pattern java is to encapsulate these algorithms into classes with the same interface. By using the same interface, we make the algorithms interchangeable with respect to the client using the algorithms strategy pattern java reduce the dependency on the algorithms from concrete algorithms to the interface that defines the algorithms.

Strategy in Java

The Context class in this diagram represents the class that uses the algorithm, while the Strategy interface represents the common contract for the algorithm. In order to gain an intuitive understanding of the Strategy pattern, we can think of the Context class as a desk, where the Strategy interface represents a slot in the desk that accepts drawers.

Additionally, each of the concrete Strategy implementations can be thought of as actual drawers, where some are completely undivided, and others have various divider configurations; some may be good at storing papers, while others may be better at organizing pens, pencils, and paper clips.

Each serves its own purpose and excels in a specific context, but vary only in their internal strategy pattern java The external configuration of each drawer is the same so that it can be accepted by the desk. This view of the Strategy pattern is nearly identical to that of interfaces in general: So long as we create an interface and depend only on that interface, we can substitute any of the implementations of that interface for one another.

This similarity is not a strategy pattern java, as strategy pattern java Strategy pattern is one of the most natural uses for interfaces. In the case of the Strategy pattern, we define a set of algorithms, select one, and then execute it.

Strategy pattern

Since the Context class is dependent on the concrete Strategy implementations in terms of the Strategy strategy pattern java, executing any of the algorithms is accomplished in the same manner, with no knowledge on the part of the Context class as to which Strategy is being executed. While we have defined our algorithm method above without arguments and with a void return type, we can define it with any number of parameters and any return type, so long as the parameters contain all of the information that is required for the concrete Strategy implementations.

In cases where there are values needed for some algorithms and not others, we must still provide all of the parameters. Therefore, we end up with the union of parameters needed for each of the concrete Strategy strategy pattern java.

In the event that the number of parameters becomes unwieldy, we can consolidate them into a parameter object using the Introduce Parameter Object refactoring technique.

Strategy pattern - Wikipedia

With a static view of the Strategy pattern established, the dynamic strategy pattern java view of the Strategy pattern is almost trivial. When a Context object is strategy pattern java and requires the execution of the desired algorithm, the current concrete Strategy object associated with the Context object is executed.

Once the algorithm completes, control strategy pattern java returned to the Context object. This concept is illustrated in the UML sequence diagram below: With a static and dynamic view of the Strategy pattern established, we will explore a complete example that will illustrate both the design decisions that go into creating a set of strategies, as well as the benefits of the Strategy pattern in various scenarios.

Examples While a theoretical understanding of the Strategy pattern is important for knowing how and when to implement the pattern in a system, seeing an example of the pattern often provides the intuitive understanding that is often missing with technical explanations.


In this section, we will walk through the creation of a simple payment processing system, where a bill can be paid using a variety strategy pattern java payment methods selected at runtime. A Payment System Walkthrough Making payments is strategy pattern java common feature of any financial or commerce system, but handling the different payment types can be a challenge, especially with all of the payment types that are currently available cash, credit, debit, Bitcoin, PayPal, etc.