1 files changed, 511 insertions, 0 deletions
diff --git a/usth/ICT2.7/P3L3 Design Patterns Subtitles/8 - Strategy Pattern Example & Demo - lang_en_vs5.srt b/usth/ICT2.7/P3L3 Design Patterns Subtitles/8 - Strategy Pattern Example & Demo - lang_en_vs5.srt
new file mode 100644
index 0000000..6d298d0
--- /dev/null
+++ b/usth/ICT2.7/P3L3 Design Patterns Subtitles/8 - Strategy Pattern Example & Demo - lang_en_vs5.srt
@@ -0,0 +1,511 @@
+1
+00:00:00,130 --> 00:00:03,320
+Now let's see how this whole thing works in practice by
+
+2
+00:00:03,320 --> 00:00:06,800
+using an example. We're going to consider a program that takes as
+
+3
+00:00:06,800 --> 00:00:10,450
+input a text file and produce it as output, a filtered
+
+4
+00:00:10,450 --> 00:00:14,170
+file. So basically it outputs a subset of the content of
+
+5
+00:00:14,170 --> 00:00:16,928
+this text file based on some filter. And we're going to have
+
+6
+00:00:16,928 --> 00:00:19,440
+four different types of filters. So the first one is
+
+7
+00:00:19,440 --> 00:00:21,680
+not filtering which means that the whole content of the text
+
+8
+00:00:21,680 --> 00:00:25,320
+file will be produced on the output. The second filter will output
+
+9
+00:00:25,320 --> 00:00:27,990
+only words that starts with t. So you'll take the text file
+
+10
+00:00:27,990 --> 00:00:30,540
+and simply ignore all of the words that do not start with
+
+11
+00:00:30,540 --> 00:00:33,130
+t. So in the output we'll have only those words that starts
+
+12
+00:00:33,130 --> 00:00:36,030
+with letter t. The third filter will produce in the output only
+
+13
+00:00:36,030 --> 00:00:39,180
+words that are longer than five characters. So all the other words
+
+14
+00:00:39,180 --> 00:00:43,740
+will be simply disregarded. And finally, the four filter will produce as
+
+15
+00:00:43,740 --> 00:00:47,630
+output only words in the text file that are palindromes, and in
+
+16
+00:00:47,630 --> 00:00:50,590
+case you don't know what a palindrome is, a palindrome is a word
+
+17
+00:00:50,590 --> 00:00:52,700
+that is the same whether you read it from left
+
+18
+00:00:52,700 --> 00:00:55,800
+to right or from right to left. For example, the
+
+19
+00:00:55,800 --> 00:00:58,480
+word kayak, you can read it in this direction, or
+
+20
+00:00:58,480 --> 00:01:00,740
+in this direction, and it's exactly the same word. So
+
+21
+00:01:00,740 --> 00:01:03,560
+let's see how this program could be implemented using a
+
+22
+00:01:03,560 --> 00:01:05,980
+strategy pattern. And let's do it for real as a
+
+23
+00:01:05,980 --> 00:01:10,100
+demo. What we're looking at here is the editor page
+
+24
+00:01:10,100 --> 00:01:15,520
+for Eclipse, open with the strategy pattern implementation for our example.
+
+25
+00:01:15,520 --> 00:01:17,130
+So what I'm going to do is that, I'm going to look at a
+
+26
+00:01:17,130 --> 00:01:20,310
+different part of implementation. And you will see that, you know, despite
+
+27
+00:01:20,310 --> 00:01:23,420
+the fact that it's slightly longer, it's really fairly simple, it's kind
+
+28
+00:01:23,420 --> 00:01:26,230
+of a straightforward implementation of what we just saw. As I just
+
+29
+00:01:26,230 --> 00:01:29,820
+said, what we are doing is basically building the strategy patterns that
+
+30
+00:01:29,820 --> 00:01:34,330
+allows for changing the strategies with which we're filtering an input file.
+
+31
+00:01:34,330 --> 00:01:37,380
+And we have different strategies, we'll look at those in detail, and
+
+32
+00:01:37,380 --> 00:01:41,050
+we said that the three participants for this pattern are the context,
+
+33
+00:01:41,050 --> 00:01:43,650
+the algorithm, which is the general interface and then the concrete
+
+34
+00:01:43,650 --> 00:01:47,270
+strategies, which are the concrete implementations of this algorithm. So let's
+
+35
+00:01:47,270 --> 00:01:49,790
+start by looking at the context. Which is this class here.
+
+36
+00:01:49,790 --> 00:01:52,960
+And as you can see it contains a reference at the current
+
+37
+00:01:52,960 --> 00:01:56,240
+strategy. We call this the check strategy, which is basically our
+
+38
+00:01:56,240 --> 00:01:59,910
+filter, and when the context is created by default it sets a
+
+39
+00:01:59,910 --> 00:02:02,890
+strategy to the old strategy. The old strategy is the one
+
+40
+00:02:02,890 --> 00:02:06,380
+that accepts all the input, so basically it doesn't filter out anything.
+
+41
+00:02:06,380 --> 00:02:08,320
+And we said that the context is the interface to the
+
+42
+00:02:08,320 --> 00:02:10,889
+outside world, right? So it has to provide the outside world
+
+43
+00:02:10,889 --> 00:02:14,140
+with a way of selecting the strategy, the specific algorithm to
+
+44
+00:02:14,140 --> 00:02:16,850
+be used, and it does that in this case by providing
+
+45
+00:02:16,850 --> 00:02:21,360
+this change strategy method. This method takes a strategy as input,
+
+46
+00:02:21,360 --> 00:02:24,930
+and simply replaces the current strategy with the one specified as
+
+47
+00:02:24,930 --> 00:02:28,035
+a parameter. And at this point, the context also will perform
+
+48
+00:02:28,035 --> 00:02:31,830
+the filtering. The filtering is pretty straightforward, so what it does is
+
+49
+00:02:31,830 --> 00:02:34,620
+that it opens a file that is passed as a parameter
+
+50
+00:02:34,620 --> 00:02:37,450
+so that this the file, the input file to be filtered. And
+
+51
+00:02:37,450 --> 00:02:40,560
+then it reads the file line by line and then splits
+
+52
+00:02:40,560 --> 00:02:43,620
+the lines into its composing words and then for each word in
+
+53
+00:02:43,620 --> 00:02:46,480
+each line, what it will do, it will basically invoke the
+
+54
+00:02:46,480 --> 00:02:50,270
+check method in the current strategy, which is basically the filtering method
+
+55
+00:02:50,270 --> 00:02:53,580
+and if the check method returns true, which basically means that
+
+56
+00:02:53,580 --> 00:02:57,150
+the word should be printed, it prints the word. Otherwise, it'll just
+
+57
+00:02:57,150 --> 00:03:00,480
+skip it. So basically the filter will return false for all the
+
+58
+00:03:00,480 --> 00:03:03,470
+words that have to be filtered out. Okay? This is the basic
+
+59
+00:03:03,470 --> 00:03:06,770
+way in which context works. Let's see how this is used in
+
+60
+00:03:06,770 --> 00:03:10,660
+our main method. The main method simply creates the context, reads the input file
+
+61
+00:03:10,660 --> 00:03:12,910
+from the arguments, and then what he does is simply as a
+
+62
+00:03:12,910 --> 00:03:16,720
+demonstration, it will perform the filtering using all the different filters. So
+
+63
+00:03:16,720 --> 00:03:19,310
+starting from the default one, which is the one that basically doesn't
+
+64
+00:03:19,310 --> 00:03:22,150
+do any filtering that reports all words, then it will switch to the
+
+65
+00:03:22,150 --> 00:03:25,400
+algorithm, that only considers the words that start with t, and
+
+66
+00:03:25,400 --> 00:03:28,880
+it will do that by invoking a change strategy and passing this
+
+67
+00:03:28,880 --> 00:03:30,890
+strategy as the argument, and then
+
+68
+00:03:30,890 --> 00:03:32,760
+performing the actual filtering through context.
+
+69
+00:03:32,760 --> 00:03:35,040
+And it will do exactly the same for the strategy that only
+
+70
+00:03:35,040 --> 00:03:37,540
+prints words that are longer than five and the one that
+
+71
+00:03:37,540 --> 00:03:40,460
+only prints words that are palindromes. So now let's look at the
+
+72
+00:03:40,460 --> 00:03:44,090
+actual algorithm. This is the interface, the algorithm interface. And you can
+
+73
+00:03:44,090 --> 00:03:47,080
+see that the only thing that the interface provides is this method,
+
+74
+00:03:47,080 --> 00:03:49,760
+which is the check method, that takes a string as input and will
+
+75
+00:03:49,760 --> 00:03:52,470
+return a boolean. So, basically, it's the boolean that we were seeing before.
+
+76
+00:03:52,470 --> 00:03:55,010
+The one that is true for the words that have to be printed
+
+77
+00:03:55,010 --> 00:03:57,490
+and false for the ones that have to be filtered out. Now, we have
+
+78
+00:03:57,490 --> 00:04:01,250
+all the different implementations of the algorithm, the simplest one is the all
+
+79
+00:04:01,250 --> 00:04:05,110
+algorithm, the simple return is always true, so all the words will be printed.
+
+80
+00:04:05,110 --> 00:04:08,740
+The second one starts with t, and again, without looking at the details
+
+81
+00:04:08,740 --> 00:04:10,660
+of implementations that don't really matter, what
+
+82
+00:04:10,660 --> 00:04:12,390
+it does is basically check that
+
+83
+00:04:12,390 --> 00:04:15,111
+the first character is t, and returns true in that case and
+
+84
+00:04:15,111 --> 00:04:17,720
+false otherwise. Similarly, for the LongerThan5
+
+85
+00:04:17,720 --> 00:04:19,380
+algorithm, also in this case, this
+
+86
+00:04:19,380 --> 00:04:23,000
+will implement the check strategy interface, and the check will be performed
+
+87
+00:04:23,000 --> 00:04:25,980
+by checking that the word is longer than five characters and returning
+
+88
+00:04:25,980 --> 00:04:29,440
+true in that case and false otherwise. And finally the Palindrome check
+
+89
+00:04:29,440 --> 00:04:32,240
+is a little more complicated, but basically it just checks whether the
+
+90
+00:04:32,240 --> 00:04:35,190
+word is a Palindrome and returns true in that case. Okay, so
+
+91
+00:04:35,190 --> 00:04:37,950
+as I said, it doesn't really matter too much what is the specific
+
+92
+00:04:37,950 --> 00:04:40,630
+implementations of these matters. What matters is that we have
+
+93
+00:04:40,630 --> 00:04:44,150
+a general interface for the algorithm and then any different concrete
+
+94
+00:04:44,150 --> 00:04:48,130
+implementations of the algorithm that implement different strategies. So again,
+
+95
+00:04:48,130 --> 00:04:50,730
+this allows you to change the behavior of your class without
+
+96
+00:04:50,730 --> 00:04:53,420
+changing class. So we have this context class that does
+
+97
+00:04:53,420 --> 00:04:57,015
+different things when the filter method in invoked, depending on what
+
+98
+00:04:57,015 --> 00:04:59,930
+is the current strategy. So the behavior of the class can
+
+99
+00:04:59,930 --> 00:05:03,310
+change dynamically, and it changes dynamically every time that we change
+
+100
+00:05:03,310 --> 00:05:06,300
+the strategy. At this point, the way this whole thing works should
+
+101
+00:05:06,300 --> 00:05:08,430
+be clear, so what we're going to do is that we're going to go to
+
+102
+00:05:08,430 --> 00:05:12,010
+our console, and we're actually going to run the strategy pattern and see
+
+103
+00:05:12,010 --> 00:05:15,710
+what happens. So here I have a file, it's called foo.txt. And if
+
+104
+00:05:15,710 --> 00:05:18,290
+we look at the content of foo, you can see that it
+
+105
+00:05:18,290 --> 00:05:21,190
+says that this is just a test to assess how well this program
+
+106
+00:05:21,190 --> 00:05:24,430
+performs when used on files of text. And since it checks for
+
+107
+00:05:24,430 --> 00:05:28,560
+palindromes, we will also insert one such word, level. Level is a palindrome,
+
+108
+00:05:28,560 --> 00:05:31,042
+because you can read it from both sides. Okay, so let's
+
+109
+00:05:31,042 --> 00:05:33,657
+see what happens when we run our code. So we're going to
+
+110
+00:05:33,657 --> 00:05:36,900
+run java pattern.strategy.StrategyPattern which is
+
+111
+00:05:36,900 --> 00:05:38,550
+our class, and we going to fetch
+
+112
+00:05:38,550 --> 00:05:41,460
+foo.txt as an input, and let's go back to the beginning
+
+113
+00:05:41,460 --> 00:05:43,980
+of the output to see what happened exactly. You can see
+
+114
+00:05:43,980 --> 00:05:48,040
+here that for the default strategy, which was the old strategy,
+
+115
+00:05:48,040 --> 00:05:50,810
+the whole file is printed, so every word is printed. This
+
+116
+00:05:50,810 --> 00:05:53,485
+is just a test to assess and so on and so forth,
+
+117
+00:05:53,485 --> 00:05:57,290
+as expected. For the filter that only prints words that
+
+118
+00:05:57,290 --> 00:06:00,230
+start with t, only words that start with t are printed,
+
+119
+00:06:00,230 --> 00:06:04,180
+again, as expected. Similarly, for the filter that only prints words
+
+120
+00:06:04,180 --> 00:06:06,970
+that are longer than 5, and finally for the one that prints
+
+121
+00:06:06,970 --> 00:06:09,540
+palindromes. And here you can see that we actually have two
+
+122
+00:06:09,540 --> 00:06:12,410
+because the way in which this is implemented we'll also consider
+
+123
+00:06:12,410 --> 00:06:15,300
+single letter words as palindromes because you can read them from
+
+124
+00:06:15,300 --> 00:06:18,450
+both sides. But you definitely will also have level in the output.
+
+125
+00:06:18,450 --> 00:06:21,040
+And in case you want to play with this code yourself, I
+
+126
+00:06:21,040 --> 00:06:24,600
+have made this code and also the implementation for examples of other
+
+127
+00:06:24,600 --> 00:06:28,440
+design partners available as a compressed archive. And the archive is accessible
+
+128
+00:06:28,440 --> 00:06:31,120
+through a URL that is provided in the notes for the cost.