From the original comments made by Bernard Sumption:

All of the pain caused by inheritance can be traced back to the fact that inheritance forces 'is-a' rather than 'has-a' relationships. If class R2Unit extends Droid, then a R2Unit is-a Droid. If class Jedi contains an instance variable of type Lightsabre, then a Jedi has-a Lightsabre.

Travis agrees and then comes back with his second post to clarify something - composition versus inheritance:

I approach OOP from a flexibility standpoint with one of its biggest flex-points being loose coupling which in turn promotes reusability. I'm going to use Event as a hypothetical example.

He uses Events and design pattern illustrations (like the Visitor and Observer) to help illustrate his point.

I'll show you how to use a static property, along with the programmatic model dictated by the observer pattern, to implement an expandable data validation system. This task might have an immediate application in a real situation.

They show how to handle user information (as defined as properties in the creation of the user objects) and pushing that data back out into the page. The observer pattern comes into play when they go to validate the user information checking to see if it's all alphabetical, numeric or an email address.

Maybe you've used a framework that uses Observers and Dispatchers, or you've heard of them but don't know how they work. Well, I'm going to explain them and tell you why they're so useful.

He starts with a table defining the parts of this dynamic duo before jumping into the code examples and explainations. His first example is just a basic use of the pattern, while the second involves using a MySQL table for the notification events.

Well, over the course of this last tutorial, I'll be moving the application of observer objects toward the real world, in this case by showing you how to include these objects within a set of form-validation classes. After reading this article, you should be equipped with a decent knowledge of how a form checking application can use the powerful features of this widely-known design pattern.

They look back first at the code for the form validation class from the previous article before moving on and building in more functionality - a FormObserver class. Finally, they pair the two classes to make a working, validating example.

Following my petty wingeing about the design patterns in php on the web I have to bite the bullet and do something about it. So here it comes a collection of design pattern examples, some from the GOF book, some collected from around the net, some (maybe) I have discovered.

The intent of these pages is to show the shapes of the patterns not a fully fledged implementation. In real life probably a combination of patterns will be employed. Everyone has their own favourites following their political, religious and style differences.

He admits that the pages are a work in progress and aren't complete, but they're a start to share his studies with the world. His list of patterns so far includes:

• Facade
• Hooks
• Protocol Method
• Singleton

Well, after refreshing some of the most important points regarding the creation of observer objects, let's focus our attention on the subject of this second tutorial. Over the next few lines, I'll be demonstrating how to apply the Observer pattern during the development of a real-world application: a form validation system.

They start with the creation of the validation classes for the different data formats. They follow it with the creation of a few more, a bit more abstract classes for validation. Finally, they tie it all in, using the Observer pattern to integrate the form data inputted and the routines to check their values.

If you have reached the point in your programming life where you are using design patterns, you will want to read this article. The first of a three-part series, it covers the Observer pattern, which can be just the thing for situations where objects need to send information to a centralized mechanism.

I hope you'll be wondering how all this boring theory can be translated into functional PHP code. That's what I'm going to do in the course of this article, by introducing some friendly examples of how to implement the Observer pattern in PHP applications.

They just right in and create a more practical example, opting for demonstration over a lot of explaination. Their sample code manipulates strings to change them to uppercase and save them off to a file. They attach a basic error logger to it and then conform it to fit in with the Observer pattern style.

The latest issue of PHP Magazine is now available. In it you will find part two of my series on design patterns in PHP, along with a host of other great articles. Check it out!

In this part of the series, he covers the decorator, strategy, and observer patterns...]]> Thu, 12 Jan 2006 06:30:41 -0600