Object orientation provides a wonderful bag of components, but they need to be linked together to provide a full set of facilities for data handling. And very often that linking together is in a way which can be standardised - along the lines of "you normally do it this way"
. Such standardised methodologies are known as Design Patterns
When teaching Object Orientation, we go through the mechanisms of the language, and application design (see "Designing your applications using UML techniques"
). And I cover a little - a very little - about design patterns. Delegates need to be aware of them, but a course that included a deep study of design methodology and patterns would be extended from what we currently offer by at least a day, with delegates who are converting
from another OO language finding that the extra time was mostly revision.
However, last week's PHP Course
ran quickly - bright delegates, all starting with more experience that our stated prerequisites, and in the training room 30 from 30 minutes before class officially started each morning. So we got on to the mechanisms of OO programming in PHP on the final afternoon of the main course, rather than starting it in the official way on the Friday morning. Which gave me time to talk about UML techniques in more detail, and to add in some more coverage of Design Patterns than is usual.
In a new source code example ([here]
), you'll find a number of design patterns in use - some being commonly accepted / named ones, others which are our / my own patterns.
There's a factory
pattern which takes raw data and creates an object from it. A factory differs from a constructor in that it often has to do preliminary work on the data, and indeed it can return objects of different types depending on the data actually passed in, and indeed it can return an array / list / hash / dictionary of objects. A factory method is a static method, provided within a class to place the logic of interpreting the incoming data source into objects, even prior to the creation of any objects.
There's a comparator
pattern, which compares two objects. Static (class) methods can work on the data for all
objects in a class, dynamic (object) methods work on a single object. Yet so often you want to compare two objects. Which is the larger? Which is the older? And that's where you'll use a comparator design pattern.
As an extension of the comparator, we often use a standard (static) pattern to find the largeest
- no formal name for this one, but you'll find an example called "longest" in the source example.
We've also got an example of a very simple getter
pattern to retrieve a property, but this particular example didn't use some of the other common design patterns such as setter
. That's fairly typical - you'll use design patterns for the standard stuff, and then your own (or modified) code beyond that to add the functionality that's unique to your data and the application thereof.
I spoke earlier about the decision we've had to take at Well House Consultants as to how far we go along teaching design methodologies and design patterns in our programming language courses. I believe we have the mix about right for most delegates who come on public courses. But if you're looking to learn about object orientation in Perl, PHP, Python, Ruby or C++, and would like an extra day or two covering the topics I describe in this article, please ask
. We can usually (diary permitting) add an extra day onto the end of our courses to cover the subjects. Typically, it will be a private course - and we'll only charge you as if it was another day on the public course. A bargain way to learn about designing your application, and learn about it in the language that you'll be using! (written 2012-02-12, updated 2012-02-25)
Associated topics are indexed underQ908 - Object Orientation and General technical topics - Object Orientation: Design Patterns 
Spike solution, refactored and reusable, Python - Example - (2013-02-28) 
Caching Design Patterns - (2012-08-20) 
Reading files, and using factories to create vectors of objects from the data in C++ - (2012-07-21) 
Learning C++ - a design pattern for your first class - (2012-05-02) 
What is a factory method and why use one? - Example in Ruby - (2010-09-30) 
What is a factory? - (2010-04-26) 
Looking for a practical standards course - (2009-08-05) 
Object Relation Mapping (ORM) - (2007-06-09) 
North, Norther and Northest - PHP 5 Objects - (2005-11-04)H108 - Objects in PHP 
Learning about Object Orientation in PHP - a new set of examples - (2013-04-28) 
stdClass in PHP - using an object rather than an associative array - (2013-04-02) 
Objects in PHP - Revision - (2012-12-16) 
Copying, duplicating, cloning an object in PHP - (2012-08-18) 
Autoload in PHP - (2012-08-17) 
How do classes relate to each other? Associated Classes - (2012-02-12) 
Designing your application - using UML techniques - (2012-02-11) 
Computer Graphics in PHP - World (incoming data) to Pixel (screen) conversion - (2011-03-24) 
Catchable fatal error in PHP ... How to catch, and alternative solutions such as JSON - (2011-03-22) 
Private and Public - and things between - (2011-01-22) 
Getting the OO design write - with PHP a example - (2010-08-14) 
Does copying a variable duplicate the contents? - (2010-08-14) 
PHP - Object Oriented Design in use - (2010-05-21) 
The Multiple Inheritance Conundrum, interfaces and mixins - (2010-04-11) 
Static class members in PHP - a documented example - (2010-03-16) 
Object Oriented Programming in PHP - (2010-02-19) 
Shipping a test harness with your class in PHP - (2010-02-12) 
Serialization - storing and reloading objects - (2009-10-04) 
Abstract classes, Interfaces, PHP and Java - (2009-10-03) 
Object Oriented programming - a practical design example - (2009-08-27) 
PHP4 v PHP5 - Object Model Difference - (2009-05-11) 
Cleaning up redundant objects - (2009-05-11) 
When should I use OO techniques? - (2009-05-11) 
PHP - getclass v instanceof - (2009-05-07) 
Introduction to Object Oriented Programming - (2008-12-06) 
Sorting objects in PHP - (2008-10-04) 
Calling base class constructors - (2008-10-03) 
Accounts in PHP - an OO demo - (2008-06-19) 
OO PHP demonstration - comparing objects and more - (2008-02-08) 
What are factory and singleton classes? - (2007-06-04) 
Object Oriented Model - a summary of changes from PHP4 to PHP5 - (2007-04-18) 
Cue the music, I'm happy. - (2007-01-09) 
Build on what you already have with OO - (2006-08-17) 
Planning a hotel refurb - an example of a Gant chart in PHP - (2006-05-14) 
Think about your design even if you don't use full UML - (2006-03-24) 
Don't repeat code - use loops or functions - (2005-08-21) 
Should I use structured or object oriented? - (2005-06-10) 
PHP5 lets you say no - (2005-02-07) 
PHP v Java - (2004-11-20) 
Object Oriented Programming in PHP - (2004-09-29)
Some other Articles
Help to get online in MelkshamA customer thanks Well House ManorTraining to do a job, or training to pass an exam?Design Patterns - what are they? Why use them?Gypsy and Billy enjoy the snowSnow comes to Melksham, Wiltshire - picturesMelksham Campus - a blog you can read, and a place you can commentAnother cold night