Re: How is this "pattern" called?

In article <96ejr7hcmgv68n2itnip55edo0cg97vj8a@4ax.com>, genew@ocis.net
says...


Let me give you an example:

You copy and modify your sorting routine for each class you like to
sort, everywhere you need it. Simple, easy, does it:

for (int i = 1; i < articles.size(); i++){
  int j = i;
  final Article actual= articles.get(i);
  while (j>0 && articles.get(j-1).getAmount() > actual.getAmount())){
   articles.set(j, articles.get(j-1));
   j--;
  }
  articles.set(j, actual);
 }

[..]

 for (int i = 1; i < articles.size(); i++){
  int j = i;
  final Article actual= articles.get(i);
  while (j>0 && articles.get(j-1).getPrice() > actual.getPrice())){
   articles.set(j, articles.get(j-1));
   j--;
  }
  articles.set(j, actual);
 }

It works, it is straightforward, so what?

If you use the strategy pattern and instead of copying and modifying the
sorting routine, just have one sorting method in a utility class, that
you need to call, provide it with a list and a comparison strategy
(Comparator):

class SortUtil{
 public static <T> sort(final List<T> items,
                        final Comparator<? super T> strategy){
  for (int i = 1; i < items.size(); i++){
   int j = i;
   final T actual= articles.get(i);
   while (j>0 && strategy.compare(items.get(j-1), actual) > 0){
    items.set(j, items.get(j-1));
    j--;
   }
   items.set(j, actual);
  }
 }
}

You then define your comparison strategy and put it somewhere where it's
easy and intuive to find:

class Article{

 public static Comparator<Article> COMPARE_BY_AMOUNT
     = new Comparator<Article>(){
  public int compare(Article a, Article b){
   return a.getAmount() - b.getAmount(); //I know it stinks of overflow!
  }
 };

 [..]

  public static Comparator<Article> COMPARE_BY_PRICE
     = new Comparator<Article>(){
  public int compare(Article a, Article b){
   return (int)(a.getPrice() - b.getPrice()); //I know it stinks hard!

  }
 };
}

That might look complicated first, but there is a huge benefit:
Wherever you sort articles, the result is quite readable:

SortUtil.sort(articles, Article.COMPARE_BY_AMOUNT);
SortUtil.sort(articles, Article.COMPARE_BY_PRICE);

Yes, you can also have that if you have a lot of copied methods like
this:
sortArticlesByAmountAsc(articles);
sortArticlesByPriceAsc(articles);

But the huge difference is: If you find an error in your sorting
routine, or if you want to change your sorting routine from insertin
sort to quicksort, you only need to fix it in one place and every code
that ises it will be fixed and sped up immediately.

You don't need to hunt down every copy that you have made (you will
forget one for sure) and apply the same change to all of them (you will
make a mistake somewhere). And since code evolves the fix might look
different everywhere, so searching for the code you need to change is
doomed to miss some occurrences.

Also you can easily re-use the comparison strategy, because is not
buried under a load of sorting loopcode, but seperate from it. You can
use it to compare two articles:

if(Article.COMPARE_BY_PRICE.compare(a1, a2)){
 highlightError(articleChoiceA);
}

Now imagine your code review shows that the code stinks as the price is
of type "double", and you need to change that for "BigDecimal", then you
can fix the Comparator once and every part of your code that uses it
instantly works - so you have saved yourself a lot of time.
You did not need to hund down every sort routine you have copied and
modified, not even search for the compiler errors in simple if-clauses
where you had a < > operator first.

And since you know the Java-API, you also know that Collections.sort()
was built the same way. For a good reason.

Kind regards,
-Wanja-

--
...Alesi's problem was that the back of the car was jumping up and down
dangerously - and I can assure you from having been teammate to
Jean Alesi and knowing what kind of cars that he can pull up with,
when Jean Alesi says that a car is dangerous - it is. [Jonathan Palmer]

--- Posted via news://freenews.netfront.net/ - Complaints to news@netfront.net ---