Now I m driving Now I m flying fast Now I m driving in Java

Encoder Code-128 in Java Now I m driving Now I m flying fast Now I m driving

As you see, switching algorithms at runtime is no problem On the other hand, if you had hardcoded specific behavior into the jet, there would have been no way to change it at runtime In other words, you can set the strategy you want to use at runtime All of which brings us to the design pattern for this chapter, which this chapter s whole discussion has really been about the Strategy design pattern

The Strategy design pattern is the first one covered in this book, and in fact you ve seen it at work throughout this chapter already This design principle comes into play when it makes sense to extract code that handles specific tasks from your app

Creating a family of algorithms lets you choose your strategy by choosing consciously which algorithm(s) you want to work with This design pattern is often used as an alternative to inheritance, where you can end up spreading out the way you handle one specific task over many class files Here s the problem, in general You may find yourself implementing a single task across several generations of classes At first, everything is fine, you handle the task in one class alone, as shown in Figure 2-1

doTask() {}

But as time goes on, special cases seem to require new classes, and you use inheritance and overriding code in the inheriting classes, spreading the way you handle the single task across a number of inheriting classes (see Figure 2-2)

doTask() {}

doTask() { Overriding code }

doTask() { More overriding code }

The Strategy design pattern says that you should extract the volatile parts of your code and encapsulate them as objects; you can use those objects as you need them Now you can customize your code by creating composites of objects At runtime, you just use polymorphism to choose the object(s) you want to work with, as shown in Figure 2-3

The GoF book says the Strategy design pattern should: Define a family of algorithms, encapsulate each one, and make them interchangeable Strategy lets the algorithm vary independently from clients that use it The Strategy design pattern points out that, sometimes, it s good to be taskoriented That s especially important if you want to maintain volatile code away from the main code for your app, or if you want to change the algorithm you use at runtime Consider using the Strategy design pattern if you have one of the following situations: You have volatile code that you can separate out of your application for easy maintenance You want to avoid muddling how you handle a task by having to split implementation code over several inherited classes You want to change the algorithm you use for a task at runtime So there you have it any time you start to get task-oriented and want to make those tasks one of the main design points of your code, the Strategy design pattern should spring to mind That s the way design patterns work They don t provide you with specific code Instead, you familiarize yourself with the idea, and when that idea could come in handy there s an Aha! moment This looks like a job for the Strategy pattern!

Knowing how various design patterns work also gives you a way of talking to other people who are familiar with those design patterns Most professional programmers should know at least some standard design patterns When someone on your team starts talking about using the Strategy design pattern and everyone starts nodding knowingly, you want to be able to nod knowingly as well