The Joomla! Forum ™





Post new topic Reply to topic  [ 6 posts ] 
Author Message
 Post subject: Objects...
PostPosted: Sat Aug 11, 2007 4:39 pm 
User avatar
Joomla! Virtuoso
Joomla! Virtuoso

Joined: Sat Sep 24, 2005 11:01 pm
Posts: 4785
Location: Toronto, Canada
Realizing my aside went on long on the other thread and not wanting to hijack it, I will post again in a new thread.  For the first part, see:
http://forum.joomla.org/index.php/topic ... #msg943596

More on Objects

As I said, Objects are called Objects for a reason.  If you have a real life object, say a photocopier, there is an external interface (say, a paper tray, the copier glass, the keypad, etc.).  Objects in OOP are designed to approximate that setup.

So, I might have a class called copier.  Now, what operations do I generally need to do with a copier?  Well, the basic functionality I need is copy functionality.  So I need a method called 'copy':

class Copier
{
    function copy() {
        echo 'One copy made';
    }
}

Now, this is a very basic copier.  What if I wanted to extend the functionality of my Copier?  Well, to extend the functionality, I create a child class.  A child class will inherit all the functionality of the parent class.

Let's suppose we wanted to create a copier that would keep track of the number of copies it had made.  So, we would need to add a property which would keep track of this number, and then we need to somehow adjust this number each time we make a copy.

So here is our child class:
class CopierWithCounter extends Copier
{
    var $counter;

    function copy() {
        $this->counter++;
        parent::copy();
    }
}

So we now have a property called $counter that keeps track of the number of copies made.  Notice that the method we defined has the same name as the method in the Copier class.  What this means is that we don't need to learn anything new to use the copier - it behaves in the same way as our old copier, but it just keep track of the number of copies.

You will see that inside of the copy() method there is a line: parent::copy().  The parent keyword references the parent class, which is in this case Copier.  So this line will invoke the copy() method of the Copier class.  In this way, we don't have to rewrite the functionality to make a copy - we have already done that in the Copier class.

So we have the exact same functionality as the Copier class, except that anytime a copy is made it will increment the $counter property by 1.  Just as in real life, the addition of the counter doesn't change the way that I use the copier - I don't need to know anything about the counter to just make a simple copy.

Now, the question arises: what value does $counter start with?  We know that it increases by one everytime a copy is made, but that is all we know.

This value needs to be initialized to a certain value.

Initializing values is generally done by what is called a constructor.  A constructor does just that - it constructs the object.  In PHP4, constructors were functions that always had the same name as the class.  In PHP5, constructors are functions with the name '__construct'.  We will use __construct here.

So our class now becomes:
class CopierWithCounter extends Copier
{
    var $counter;

    function __construct() {
        $this->counter = 0;
    }

    function copy() {
        $this->counter++;
        parent::copy();
    }
}


Now suppose we wanted to create an even more advanced copier.  We can do that by creating another child class.  Let's create a copier that is able to do multiple copies.  In order to do this, we need a way to specify how many copies we want and a way to remember this number.  We will add a method called 'setCopies()':
class CopierMultipleCopies extends CopierWithCounter
{
    var $copies;

    function setCopies( $copies ) {
        $this->copies = $copies;
    }
}

We now have a way to specify how many copies we want to make.

Now, it is appropriate here to say a word about scope.  When we talk about scope, we talk about where a certain variable can be seen.  You will notice that in our class, we have a property called $copies.  But we also have a parameter called $copies in our method setCopies.  How do you tell them apart?

Well, the rules of scope tell us which variable we are talking about.  If a method takes a parameter, say $copies (as above), then if I use $copies inside that method, I am referring to that parameter.  There may be other variables called $copies that are defined in other places, but I don't care about those - I only care about the one inside of my function.  If I want to refer to a property of the current object, I use the $this keyword.  So, if I use $this->copies, then I am talking about the $copies property that belongs to my current object.

So that aside, our setCopies() method will allow us to set the number of copies that we want to make using our copier.  The method takes one parameter - $copies, and stores it in the object.

You will notice that our current class definition for CopierMultipleCopies doesn't define a copy() method or a constructor.  But, because it extends CopierWithCounter, it inherits the copy() method from CopierWithCounter, and also inherits the properties.  So, without doing any extra work, we already have a Copier with a counter.

But we still want to extend the functionality of the copy() method so that it actually makes the multiple copies.  So, we add a method definition to our class.  We will also add a constructor that will add the functionality of initializing the number of copies to 1.
class CopierMultipleCopies extends CopierWithCounter
{
    var $copies;

    function __construct() {
        $this->copies = 1;
        parent::__construct();
    }

    function setCopies( $copies ) {
        $this->copies = $copies;
    }

    function copy() {
        for ($i = 0; $i < $this->copies; $i++) {
            parent::copy();
        }
    }
}
So what have we done here?  Well, first, in our constructor we initialized the $copies variable to 1.  Thus, if we don't tell our copier otherwise, it will make one copy when the copy() method is invoked.  Note that we don't have to rewrite the code to initialize the counter - we just call parent::__construct() and our parent constructor will handle that.

Then, we overrode the copy() method.  Inside of our copy() method we have what is called a 'for loop' (see http://en.wikipedia.org/wiki/For_loop).  In the first line of the for loop, you will see three parts divided by semicolons.  The first part is the counter initialization.  We will use $i as a counter variable, and we will start it at 0.  $i will essentially keep track fo the number of copies we have made out of the total number that we have to do.  The second part is the condition.  At the beginning of each run of the for loop, this condition is checked to determine if it is true or not.  If the condition is true, we execute the stuff inside of the braces.  If it is not, then we are done the loop.  The last part is the incrementor.  This is code that gets executed after every pass through the loop.  So it will run something like:
1: take our variable i and set it to 0.
2: Check if our variable i is less than the number of copies that we have to make
3: if it is, then we will make a copy
4: we will increment i by 1 and go back to step 2

You can have much more complex for loops than this, but this is the basic idea.

So that is our copier.  Now to use our copier, we can add something like this to our code:

$copier = new CopierMultipleCopies();
$copier->copy();
$copier->copy();
$copier->setCopies( 10 );
$copier->copy();

So notice a couple of things:
First, as we made our copier more and more complex, we didn't have to duplicate code.  That is, in our most complex copier, we didn't have to worry about creating code to make the actual copy.  We just used the method that came with our original copier.  Also, in our final copier we didn't have to reimplement the counter - we again just used the method that had already been defined to do this.

Second, our new copier can serve as a drop in replacement for our old copier.  Yes, each copier was more advanced than the previous one, but it was still possible with the most advanced one to just create it and invoke the copy() method, and it would create a copy.  If I want to use the more advanced functionality, such as reading the counter or changing the number of copies to be made, I need to know about these features, but I can still ignorantly use the copier as if it was the original Copier.  i.e. the original Copier class had a certain interface that was standard.  The advanced copiers added more features, but this was separate from the original interface.  (just as a car with cruise control has the same basic interface as a car without cruise control, but to take advantage of the cruise control you need to know how to set it).  This idea is an important part of the design of Joomla!

Anyway, hope this is helpful, and as always, feel free to ask questions.


Last edited by ianmac on Fri Oct 12, 2007 1:41 pm, edited 1 time in total.

Top
 Profile  
 
 Post subject: Re: Objects...
PostPosted: Mon Aug 13, 2007 8:17 pm 
User avatar
Joomla! Guru
Joomla! Guru

Joined: Wed Jul 04, 2007 4:54 am
Posts: 925
Location: Kuala Lumpur, Malaysia
question : to what nested level is classification allowed in PHP? one can have a class of a class of a class...etc.
as like function of a function of a function, it does not render well for readability. and using PHP doesn't help readablity at all.

_________________
http://www.joomlah.net [] http://www.joomlah.org


Top
 Profile  
 
 Post subject: Re: Objects...
PostPosted: Tue Aug 14, 2007 4:05 am 
User avatar
Joomla! Apprentice
Joomla! Apprentice

Joined: Sat Oct 07, 2006 12:36 pm
Posts: 44
Location: Uberlândia, MG, Brazil
I wrote a post here, about the getPublicProperties method (JObject).

I didn´t mention protected properties. Is $_errors property private or protected? I´d like to hear some words before modifying my post.

Thank you!


Top
 Profile  
 
 Post subject: Re: Objects...
PostPosted: Tue Aug 14, 2007 9:50 pm 
User avatar
Joomla! Enthusiast
Joomla! Enthusiast

Joined: Fri Aug 19, 2005 6:11 am
Posts: 174
Location: Oamaru,New Zealand
Quote:
question : to what nested level is classification allowed in PHP? one can have a class of a class of a class...etc.
as like function of a function of a function, it does not render well for readability. and using PHP doesn't help readablity at all.


As a rule-of-thumb, no more than 3 deep ( Parent, child, grandchild ), else it can get confusing and slow things down, especially if they
are large classes.


Top
 Profile  
 
 Post subject: Re: Objects...
PostPosted: Fri Oct 12, 2007 6:40 am 
User avatar
Joomla! Apprentice
Joomla! Apprentice

Joined: Tue Mar 14, 2006 7:38 pm
Posts: 13
Location: Hannover - Germany
Thanks for this tutorial, it helps a lot!

ianmac wrote:
So we have the exact same functionality as the Copier class, except that anytime a copy is made it will increment the $copies property by 1.  Just as in real life, the addition of the counter doesn't change the way that I use the copier - I don't need to know anything about the counter to just make a simple copy.

Now, the question arises: what value does $copies have to start with?  We know that it increases by one everytime a copy is made, but that is all we know.


Aren't we really talking about $counter here instead of $copies? Or am I still getting confused?

Regards, Alex


Top
 Profile  
 
 Post subject: Re: Objects...
PostPosted: Fri Oct 12, 2007 1:42 pm 
User avatar
Joomla! Virtuoso
Joomla! Virtuoso

Joined: Sat Sep 24, 2005 11:01 pm
Posts: 4785
Location: Toronto, Canada
Fixed, thanks.  You were right.

Ian


Top
 Profile  
 
Display posts from previous:  Sort by  
Post new topic Reply to topic  [ 6 posts ] 



Who is online

Users browsing this forum: No registered users and 2 guests


You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot post attachments in this forum

Jump to:  
Powered by phpBB® Forum Software © phpBB Group