Got 5­minutes? We'd love you to share some of your thoughts regarding Envato.  Take the survey.

 Code 
Categories Learning Guides Forum

B A CK ­E N D

Object­Oriented PHP for
Beginners
by Jason Lengstorf 23 Dec 2011  682 Comments English

 538  113  571 

For many PHP programmers, object­oriented programming is a frightening concept,
full of complicated syntax and other roadblocks. As detailed in my book, Pro PHP
and jQuery, you'll learn the concepts behind object­oriented programming (OOP),
a style of coding in which related actions are grouped into classes to aid in creating
more­compact, effective code.

Understanding Object­Oriented Programming
Object­oriented programming is a style of coding that allows developers to group
similar tasks into classes. This helps keep code following the tenet "don't repeat
yourself" (DRY) and easy­to­maintain.

"Object­oriented programming is a style of coding that
allows developers to group similar tasks into classes."

One of the major benefits of DRY programming is that, if a piece of information
changes in your program, usually only one change is required to update the
code. One of the biggest nightmares for developers is maintaining code where data
is declared over and over again, meaning any changes to the program become an
infinitely more frustrating game of Where's Waldo? as they hunt for duplicated data
and functionality.

OOP is intimidating to a lot of developers because it introduces new syntax and, at a
glance, appears to be far more complex than simple procedural, or inline, code.
However, upon closer inspection, OOP is actually a very straightforward and
ultimately simpler approach to programming.

Understanding Objects and Classes
Before you can get too deep into the finer points of OOP, a basic understanding of
the differences between objects and classes is necessary. This section will go over
the building blocks of classes, their different capabilities, and some of their uses.

Recognizing the Differences Between Objects and Classes

Photos by Instant Jefferson and John Wardell

Developers start talking about objects and classes, and
they appear to be interchangeable terms. This is not the
case, however.

Right off the bat, there's confusion in OOP: seasoned developers start talking about
objects and classes, and they appear to be interchangeable terms. This is not the
case, however, though the difference can be tough to wrap your head around at first.

A class, for example, is like a blueprint for a house. It defines the shape of the
house on paper, with relationships between the different parts of the house clearly
defined and planned out, even though the house doesn't exist.
An object, then, is like the actual house built according to that blueprint. The data
stored in the object is like the wood, wires, and concrete that compose the house:
without being assembled according to the blueprint, it's just a pile of stuff. However,
when it all comes together, it becomes an organized, useful house.

Classes form the structure of data and actions and use that information to
build objects. More than one object can be built from the same class at the same
time, each one independent of the others. Continuing with our construction analogy,
it's similar to the way an entire subdivision can be built from the same blueprint: 150
different houses that all look the same but have different
families and decorations inside.

Structuring Classes
The syntax to create a class is pretty straightforward: declare a class using the
class  keyword, followed by the name of the class and a set of curly braces ( {} ):

1 <?php
2  
3 class MyClass
4 {
5   // Class properties and methods go here
6 }
7  
8 ?>

After creating the class, a new class can be instantiated and stored in a variable
using the  new  keyword:

1 $obj = new MyClass;

To see the contents of the class, use  var_dump() :

1 var_dump($obj);

Try out this process by putting all the preceding code in a new file called  test.php
in [your local] testing folder:

01 <?php
02  
03 class MyClass
04 {
    // Class properties and methods go here
 05     // Class properties and methods go here
06 }
07  
08 $obj = new MyClass;
09  
10 var_dump($obj);
11  
12 ?>

Load the page in your browser at  http://localhost/test.php  and the following

should display:

1 object(MyClass)#1 (0) { }

In its simplest form, you've just completed your first OOP script.

Defining Class Properties
To add data to a class, properties, or class­specific variables, are used. These work
exactly like regular variables, except they're bound to the object and therefore can
only be accessed using the object.

To add a property to  MyClass , add the following code to your script:

01 <?php
02  
03 class MyClass
04 {
05   public $prop1 = "I'm a class property!";
06 }
07  
08 $obj = new MyClass;
09  
10 var_dump($obj);
11  
12 ?>

The keyword  public  determines the visibility of the property, which you'll learn

about a little later in this chapter. Next, the property is named using standard
variable syntax, and a value is assigned (though class properties do not need an
initial value).

To read this property and output it to the browser, reference the object from which to
read and the property to be read:

1 echo $obj‐>prop1;

Because multiple instances of a class can exist, if the individual object is not
referenced, the script would be unable to determine which object to read from. The
use of the arrow ( ‐> ) is an OOP construct that accesses the contained properties
and methods of a given object.

Modify the script in  test.php  to read out the property rather than dumping the

whole class by modifying the code as shown:

01 <?php
02  
03 class MyClass
04 {
05   public $prop1 = "I'm a class property!";
06 }
07  
08 $obj = new MyClass;
09  
10 echo $obj‐>prop1; // Output the property
11  
12 ?>

Reloading your browser now outputs the following:

1 I'm a class property!

Defining Class Methods
Methods are class­specific functions. Individual actions that an object will be able to
perform are defined within the class as methods.

For instance, to create methods that would set and get the value of the class
property  $prop1 , add the following to your code:

01 <?php
02  
03 class MyClass
04 {
  public $prop1 = "I'm a class property!";
 {
05   public $prop1 = "I'm a class property!";
06  
07   public function setProperty($newval)
08   {
09       $this‐>prop1 = $newval;
10   }
11  
12   public function getProperty()
13   {
14       return $this‐>prop1 . "<br />";
15   }
16 }
17  
18 $obj = new MyClass;
19  
20 echo $obj‐>prop1;
21  
22 ?>

Note — OOP allows objects to reference themselves using  $this . When working

within a method, use  $this  in the same way you would use the object name
outside the class.

To use these methods, call them just like regular functions, but first, reference the
object they belong to. Read the property from  MyClass , change its value, and read it
out again by making the modifications below:

01 <?php
02  
03 class MyClass
04 {
05   public $prop1 = "I'm a class property!";
06  
07   public function setProperty($newval)
08   {
09       $this‐>prop1 = $newval;
10   }
11  
12   public function getProperty()
13   {
14       return $this‐>prop1 . "<br />";
15   }
16 }
17  
18 $obj = new MyClass;
19  
20 echo $obj‐>getProperty(); // Get the property value
21  
22 $obj‐>setProperty("I'm a new property value!"); // Set a new one
23  
24 echo $obj‐>getProperty(); // Read it out again to show the change
25  
26 ?>
 26 ?>

Reload your browser, and you'll see the following:

1 I'm a class property!
2 I'm a new property value!

"The power of OOP becomes apparent when using
multiple instances of the
same class."

01 <?php
02  
03 class MyClass
04 {
05   public $prop1 = "I'm a class property!";
06  
07   public function setProperty($newval)
08   {
09       $this‐>prop1 = $newval;
10   }
11  
12   public function getProperty()
13   {
14       return $this‐>prop1 . "<br />";
15   }
16 }
17  
18 // Create two objects
19 $obj = new MyClass;
20 $obj2 = new MyClass;
21  
22 // Get the value of $prop1 from both objects
23 echo $obj‐>getProperty();
24 echo $obj2‐>getProperty();
25  
26 // Set new values for both objects
27 $obj‐>setProperty("I'm a new property value!");
28 $obj2‐>setProperty("I belong to the second instance!");
29  
30 // Output both objects' $prop1 value
31 echo $obj‐>getProperty();
32 echo $obj2‐>getProperty();
33  
34 ?>

When you load the results in your browser, they read as follows:
 1 I'm a class property!
2 I'm a class property!
3 I'm a new property value!
4 I belong to the second instance!

As you can see, OOP keeps objects as separate entities, which makes for easy
separation of different pieces of code into small, related bundles.

Magic Methods in OOP
To make the use of objects easier, PHP also provides a number of magic methods,
or special methods that are called when certain common actions occur within
objects. This allows developers to perform a number of useful tasks with relative
ease.

Using Constructors and Destructors
When an object is instantiated, it's often desirable to set a few things right off the bat.
To handle this, PHP provides the magic method  __construct() , which is called
automatically whenever a new object is
created.

For the purpose of illustrating the concept of constructors, add a constructor to
MyClass  that will output a message whenever a new instance of the class is
created:

01 <?php
02  
03 class MyClass
04 {
05   public $prop1 = "I'm a class property!";
06  
07   public function __construct()
08   {
09       echo 'The class "', __CLASS__, '" was initiated!<br />';
10   }
11  
12   public function setProperty($newval)
13   {
14       $this‐>prop1 = $newval;
15   }
16  
17   public function getProperty()
18   {
19       return $this‐>prop1 . "<br />";
20   }
 20   }
21 }
22  
23 // Create a new object
24 $obj = new MyClass;
25  
26 // Get the value of $prop1
27 echo $obj‐>getProperty();
28  
29 // Output a message at the end of the file
30 echo "End of file.<br />";
31  
32 ?>

Note —  __CLASS__  returns the name of the class in which it is called; this is what is

known as a magic constant. There are several available magic constants, which you
can read more about in the PHP manual.

Reloading the file in your browser will produce the following result:

1 The class "MyClass" was initiated!
2 I'm a class property!
3 End of file.

To call a function when the object is destroyed, the  __destruct()  magic method is

available. This is useful for class cleanup (closing a database connection, for
instance).

Output a message when the object is destroyed by defining the magic method
__destruct()  in  MyClass :

01 <?php
02  
03 class MyClass
04 {
05   public $prop1 = "I'm a class property!";
06  
07   public function __construct()
08   {
09       echo 'The class "', __CLASS__, '" was initiated!<br />';
10   }
11  
12   public function __destruct()
13   {
14       echo 'The class "', __CLASS__, '" was destroyed.<br />';
15   }
16  
17   public function setProperty($newval)
  {
 17   public function setProperty($newval)
18   {
19       $this‐>prop1 = $newval;
20   }
21  
22   public function getProperty()
23   {
24       return $this‐>prop1 . "<br />";
25   }
26 }
27  
28 // Create a new object
29 $obj = new MyClass;
30  
31 // Get the value of $prop1
32 echo $obj‐>getProperty();
33  
34 // Output a message at the end of the file
35 echo "End of file.<br />";
36  
37 ?>

With a destructor defined, reloading the test file results in the following output:

1 The class "MyClass" was initiated!
2 I'm a class property!
3 End of file.
4 The class "MyClass" was destroyed.

"When the end of a file is reached, PHP automatically
releases all resources."

To explicitly trigger the destructor, you can destroy the object using the
function  unset() :

01 <?php
02  
03 class MyClass
04 {
05   public $prop1 = "I'm a class property!";
06  
07   public function __construct()
08   {
09       echo 'The class "', __CLASS__, '" was initiated!<br />';
10   }
11  
12   public function __destruct()
13   {
14       echo 'The class "', __CLASS__, '" was destroyed.<br />';
15   }
 15   }
16  
17   public function setProperty($newval)
18   {
19       $this‐>prop1 = $newval;
20   }
21  
22   public function getProperty()
23   {
24       return $this‐>prop1 . "<br />";
25   }
26 }
27  
28 // Create a new object
29 $obj = new MyClass;
30  
31 // Get the value of $prop1
32 echo $obj‐>getProperty();
33  
34 // Destroy the object
35 unset($obj);
36  
37 // Output a message at the end of the file
38 echo "End of file.<br />";
39  
40 ?>

Now the result changes to the following when loaded in your browser:

1 The class "MyClass" was initiated!
2 I'm a class property!
3 The class "MyClass" was destroyed.
4 End of file.

Converting to a String
To avoid an error if a script attempts to output  MyClass  as a string, another magic
method is used called  __toString() .

Without  __toString() , attempting to output the object as a string results in a fatal

error. Attempt to use  echo  to output the object without a magic method in place:

01 <?php
02  
03 class MyClass
04 {
05   public $prop1 = "I'm a class property!";
06  
07   public function __construct()
08   {
      echo 'The class "', __CLASS__, '" was initiated!<br />';
 08   {
09       echo 'The class "', __CLASS__, '" was initiated!<br />';
10   }
11  
12   public function __destruct()
13   {
14       echo 'The class "', __CLASS__, '" was destroyed.<br />';
15   }
16  
17   public function setProperty($newval)
18   {
19       $this‐>prop1 = $newval;
20   }
21  
22   public function getProperty()
23   {
24       return $this‐>prop1 . "<br />";
25   }
26 }
27  
28 // Create a new object
29 $obj = new MyClass;
30  
31 // Output the object as a string
32 echo $obj;
33  
34 // Destroy the object
35 unset($obj);
36  
37 // Output a message at the end of the file
38 echo "End of file.<br />";
39  
40 ?>

This results in the following:

1 The class "MyClass" was initiated!
2  
3 Catchable fatal error: Object of class MyClass could not be converted to string in /A

To avoid this error, add a  __toString()  method:

01 <?php
02  
03 class MyClass
04 {
05   public $prop1 = "I'm a class property!";
06  
07   public function __construct()
08   {
09       echo 'The class "', __CLASS__, '" was initiated!<br />';
10   }
 10   }
11  
12   public function __destruct()
13   {
14       echo 'The class "', __CLASS__, '" was destroyed.<br />';
15   }
16  
17   public function __toString()
18   {
19       echo "Using the toString method: ";
20       return $this‐>getProperty();
21   }
22  
23   public function setProperty($newval)
24   {
25       $this‐>prop1 = $newval;
26   }
27  
28   public function getProperty()
29   {
30       return $this‐>prop1 . "<br />";
31   }
32 }
33  
34 // Create a new object
35 $obj = new MyClass;
36  
37 // Output the object as a string
38 echo $obj;
39  
40 // Destroy the object
41 unset($obj);
42  
43 // Output a message at the end of the file
44 echo "End of file.<br />";
45  
46 ?>

In this case, attempting to convert the object to a string results in a call to the
getProperty()  method. Load the test script in your browser to see the result:

1 The class "MyClass" was initiated!
2 Using the toString method: I'm a class property!
3 The class "MyClass" was destroyed.
4 End of file.

Tip — In addition to the magic methods discussed in this section, several others are
available. For a complete list of magic methods, see the PHP manual page.
Using Class Inheritance
Classes can inherit the methods and properties of another class using the
extends  keyword. For instance, to create a second class that extends  MyClass  and
adds a method, you would add the following to your test file:

01 <?php
02  
03 class MyClass
04 {
05   public $prop1 = "I'm a class property!";
06  
07   public function __construct()
08   {
09       echo 'The class "', __CLASS__, '" was initiated!<br />';
10   }
11  
12   public function __destruct()
13   {
14       echo 'The class "', __CLASS__, '" was destroyed.<br />';
15   }
16  
17   public function __toString()
18   {
19       echo "Using the toString method: ";
20       return $this‐>getProperty();
21   }
22  
23   public function setProperty($newval)
24   {
25       $this‐>prop1 = $newval;
26   }
27  
28   public function getProperty()
29   {
30       return $this‐>prop1 . "<br />";
31   }
32 }
33  
34 class MyOtherClass extends MyClass
35 {
36   public function newMethod()
37   {
38       echo "From a new method in " . __CLASS__ . ".<br />";
39   }
40 }
41  
42 // Create a new object
43 $newobj = new MyOtherClass;
44  
45 // Output the object as a string
46 echo $newobj‐>newMethod();
47  
48 // Use a method from the parent class
 48 // Use a method from the parent class
49 echo $newobj‐>getProperty();
50  
51 ?>

Upon reloading the test file in your browser, the following is output:

1 The class "MyClass" was initiated!
2 From a new method in MyOtherClass.
3 I'm a class property!
4 The class "MyClass" was destroyed.

Overwriting Inherited Properties and Methods
To change the behavior of an existing property or method in the new class, you can
simply overwrite it by declaring it again in the new class:

01 <?php
02  
03 class MyClass
04 {
05   public $prop1 = "I'm a class property!";
06  
07   public function __construct()
08   {
09       echo 'The class "', __CLASS__, '" was initiated!<br />';
10   }
11  
12   public function __destruct()
13   {
14       echo 'The class "', __CLASS__, '" was destroyed.<br />';
15   }
16  
17   public function __toString()
18   {
19       echo "Using the toString method: ";
20       return $this‐>getProperty();
21   }
22  
23   public function setProperty($newval)
24   {
25       $this‐>prop1 = $newval;
26   }
27  
28   public function getProperty()
29   {
30       return $this‐>prop1 . "<br />";
31   }
32 }
33  
34 class MyOtherClass extends MyClass
35 {
 35 {
36   public function __construct()
37   {
38       echo "A new constructor in " . __CLASS__ . ".<br />";
39   }
40  
41   public function newMethod()
42   {
43       echo "From a new method in " . __CLASS__ . ".<br />";
44   }
45 }
46  
47 // Create a new object
48 $newobj = new MyOtherClass;
49  
50 // Output the object as a string
51 echo $newobj‐>newMethod();
52  
53 // Use a method from the parent class
54 echo $newobj‐>getProperty();
55  
56 ?>

This changes the output in the browser to:

1 A new constructor in MyOtherClass.
2 From a new method in MyOtherClass.
3 I'm a class property!
4 The class "MyClass" was destroyed.

Preserving Original Method Functionality While Overwriting
Methods
To add new functionality to an inherited method while keeping the original method
intact, use the  parent  keyword with the scope resolution operator ( :: ):

01 <?php
02  
03 class MyClass
04 {
05   public $prop1 = "I'm a class property!";
06  
07   public function __construct()
08   {
09       echo 'The class "', __CLASS__, '" was initiated!<br />';
10   }
11  
12   public function __destruct()
13   {
14       echo 'The class "', __CLASS__, '" was destroyed.<br />';
15   }
16  
 16  
17   public function __toString()
18   {
19       echo "Using the toString method: ";
20       return $this‐>getProperty();
21   }
22  
23   public function setProperty($newval)
24   {
25       $this‐>prop1 = $newval;
26   }
27  
28   public function getProperty()
29   {
30       return $this‐>prop1 . "<br />";
31   }
32 }
33  
34 class MyOtherClass extends MyClass
35 {
36   public function __construct()
37   {
38       parent::__construct(); // Call the parent class's constructor
39       echo "A new constructor in " . __CLASS__ . ".<br />";
40   }
41  
42   public function newMethod()
43   {
44       echo "From a new method in " . __CLASS__ . ".<br />";
45   }
46 }
47  
48 // Create a new object
49 $newobj = new MyOtherClass;
50  
51 // Output the object as a string
52 echo $newobj‐>newMethod();
53  
54 // Use a method from the parent class
55 echo $newobj‐>getProperty();
56  
57 ?>

This outputs the result of both the parent constructor and the new class's
constructor:

1 The class "MyClass" was initiated!
2 A new constructor in MyOtherClass.
3 From a new method in MyOtherClass.
4 I'm a class property!
5 The class "MyClass" was destroyed.
Assigning the Visibility of Properties and
Methods

For added control over objects, methods and properties are assigned visibility. This
controls how and from where properties and methods can be accessed. There are
three visibility keywords:  public ,  protected , and  private . In addition to its
visibility, a method or property can be declared as  static , which allows them to be
accessed without an instantiation of the class.

"For added control over objects, methods and
properties are assigned visibility."

Note — Visibility is a new feature as of PHP 5. For information on OOP compatibility
with PHP 4, see the PHP manual page.

Public Properties and Methods
All the methods and properties you've used so far have been public. This means that
they can be accessed anywhere, both within the class and externally.

Protected Properties and Methods
When a property or method is declared  protected , it can only be accessed within
the class itself or in descendant classes (classes that extend the class containing
the protected method).

Declare the  getProperty()  method as protected in  MyClass  and try to access it

directly from outside the class:

01 <?php
02  
03 class MyClass
04 {
05   public $prop1 = "I'm a class property!";
06  
07   public function __construct()
08   {
09       echo 'The class "', __CLASS__, '" was initiated!<br />';
10   }
11  
12   public function __destruct()
13   {
14       echo 'The class "', __CLASS__, '" was destroyed.<br />';
15   }
16  
 16  
17   public function __toString()
18   {
19       echo "Using the toString method: ";
20       return $this‐>getProperty();
21   }
22  
23   public function setProperty($newval)
24   {
25       $this‐>prop1 = $newval;
26   }
27  
28   protected function getProperty()
29   {
30       return $this‐>prop1 . "<br />";
31   }
32 }
33  
34 class MyOtherClass extends MyClass
35 {
36   public function __construct()
37   {
38       parent::__construct();
39 echo "A new constructor in " . __CLASS__ . ".<br />";
40   }
41  
42   public function newMethod()
43   {
44       echo "From a new method in " . __CLASS__ . ".<br />";
45   }
46 }
47  
48 // Create a new object
49 $newobj = new MyOtherClass;
50  
51 // Attempt to call a protected method
52 echo $newobj‐>getProperty();
53  
54 ?>

Upon attempting to run this script, the following error shows up:

1 The class "MyClass" was initiated!
2 A new constructor in MyOtherClass.
3  
4 Fatal error: Call to protected method MyClass::getProperty() from context 

Now, create a new method in  MyOtherClass  to call the  getProperty()  method:

01 <?php
02  
03 class MyClass
03 class MyClass
04 {
05   public $prop1 = "I'm a class property!";
06  
07   public function __construct()
08   {
09       echo 'The class "', __CLASS__, '" was initiated!<br />';
10   }
11  
12   public function __destruct()
13   {
14       echo 'The class "', __CLASS__, '" was destroyed.<br />';
15   }
16  
17   public function __toString()
18   {
19       echo "Using the toString method: ";
20       return $this‐>getProperty();
21   }
22  
23   public function setProperty($newval)
24   {
25       $this‐>prop1 = $newval;
26   }
27  
28   protected function getProperty()
29   {
30       return $this‐>prop1 . "<br />";
31   }
32 }
33  
34 class MyOtherClass extends MyClass
35 {
36   public function __construct()
37   {
38       parent::__construct();
39 echo "A new constructor in " . __CLASS__ . ".<br />";
40   }
41  
42   public function newMethod()
43   {
44       echo "From a new method in " . __CLASS__ . ".<br />";
45   }
46  
47   public function callProtected()
48   {
49       return $this‐>getProperty();
50   }
51 }
52  
53 // Create a new object
54 $newobj = new MyOtherClass;
55  
56 // Call the protected method from within a public method
57 echo $newobj‐>callProtected();
58  
59 ?>
This generates the desired result:

1 The class "MyClass" was initiated!
2 A new constructor in MyOtherClass.
3 I'm a class property!
4 The class "MyClass" was destroyed.

Private Properties and Methods
A property or method declared  private  is accessible only from within the class
that defines it. This means that even if a new class extends the class that defines a
private property, that property or method will not be available at all within the child
class.

To demonstrate this, declare  getProperty()  as private in  MyClass , and attempt to

call  callProtected()  from
MyOtherClass :

01 <?php
02  
03 class MyClass
04 {
05   public $prop1 = "I'm a class property!";
06  
07   public function __construct()
08   {
09       echo 'The class "', __CLASS__, '" was initiated!<br />';
10   }
11  
12   public function __destruct()
13   {
14       echo 'The class "', __CLASS__, '" was destroyed.<br />';
15   }
16  
17   public function __toString()
18   {
19       echo "Using the toString method: ";
20       return $this‐>getProperty();
21   }
22  
23   public function setProperty($newval)
24   {
25       $this‐>prop1 = $newval;
26   }
27  
28   private function getProperty()
29   {
30       return $this‐>prop1 . "<br />";
31   }
 31   }
32 }
33  
34 class MyOtherClass extends MyClass
35 {
36   public function __construct()
37   {
38       parent::__construct();
39       echo "A new constructor in " . __CLASS__ . ".<br />";
40   }
41  
42   public function newMethod()
43   {
44       echo "From a new method in " . __CLASS__ . ".<br />";
45   }
46  
47   public function callProtected()
48   {
49       return $this‐>getProperty();
50   }
51 }
52  
53 // Create a new object
54 $newobj = new MyOtherClass;
55  
56 // Use a method from the parent class
57 echo $newobj‐>callProtected();
58  
59 ?>

Reload your browser, and the following error appears:

1 The class "MyClass" was initiated!
2 A new constructor in MyOtherClass.
3  
4 Fatal error: Call to private method MyClass::getProperty() from context 'MyOtherClass

Static Properties and Methods
A method or property declared  static  can be accessed without first instantiating
the class; you simply supply the class name, scope resolution operator, and the
property or method name.

"One of the major benefits to using static properties is
that they keep their stored values for the duration of the
script."

To demonstrate this, add a static property called  $count  and a static method called

plusOne()  to  MyClass . Then set up a  do...while  loop to output the incremented
value of  $count  as long as the value is less than 10:

01 <?php
02  
03 class MyClass
04 {
05   public $prop1 = "I'm a class property!";
06  
07   public static $count = 0;
08  
09   public function __construct()
10   {
11       echo 'The class "', __CLASS__, '" was initiated!<br />';
12   }
13  
14   public function __destruct()
15   {
16       echo 'The class "', __CLASS__, '" was destroyed.<br />';
17   }
18  
19   public function __toString()
20   {
21       echo "Using the toString method: ";
22       return $this‐>getProperty();
23   }
24  
25   public function setProperty($newval)
26   {
27       $this‐>prop1 = $newval;
28   }
29  
30   private function getProperty()
31   {
32       return $this‐>prop1 . "<br />";
33   }
34  
35   public static function plusOne()
36   {
37       return "The count is " . ++self::$count . ".<br />";
38   }
39 }
40  
41 class MyOtherClass extends MyClass
42 {
43   public function __construct()
44   {
45       parent::__construct();
46       echo "A new constructor in " . __CLASS__ . ".<br />";
47   }
48  
49   public function newMethod()
50   {
51       echo "From a new method in " . __CLASS__ . ".<br />";
52   }
53  
 53  
54   public function callProtected()
55   {
56       return $this‐>getProperty();
57   }
58 }
59  
60 do
61 {
62   // Call plusOne without instantiating MyClass
63   echo MyClass::plusOne();
64 } while ( MyClass::$count < 10 );
65  
66 ?>

Note — When accessing static properties, the dollar sign
( $ ) comes after the scope resolution operator.

When you load this script in your browser, the following is output:

01 The count is 1.
02 The count is 2.
03 The count is 3.
04 The count is 4.
05 The count is 5.
06 The count is 6.
07 The count is 7.
08 The count is 8.
09 The count is 9.
10 The count is 10.

Commenting with DocBlocks

"The DocBlock commenting style is a widely
accepted method of documenting classes."

While not an official part of OOP, the DocBlock commenting style is a widely
accepted method of documenting classes. Aside from providing a standard for
developers to use when writing code, it has also been adopted by many of the most
popular software development kits (SDKs), such as Eclipse and NetBeans, and will
be used to generate code hints.

A DocBlock is defined by using a block comment that starts with an additional
asterisk:

1 /**
2  * This is a very basic DocBlock
3  */

The real power of DocBlocks comes with the ability to use tags, which start with an
at symbol ( @ ) immediately followed by the tag name and the value of the tag.
DocBlock tags allow developers to define authors of a file, the license for a
class, the property or method information, and other useful information.

The most common tags used follow:

@author: The author of the current element (which might be a class, file,
method, or any bit of code) are listed using this tag. Multiple author tags can be
used in the same DocBlock if more than one author is credited. The format for
the author name is  John Doe <[email protected]> .
@copyright: This signifies the copyright year and name of the copyright holder
for the current element. The format is  2010 Copyright Holder .
@license: This links to the license for the current element. The format for the
license information is
http://www.example.com/path/to/license.txt License Name .
@var: This holds the type and description of a variable or class property. The
format is  type element description .
@param: This tag shows the type and description of a function or method
parameter. The format is  type $element_name element description .
@return: The type and description of the return value of a function or method
are provided in this tag. The format is  type return element description .

A sample class commented with DocBlocks might look like this:

01 <?php
02  
03 /**
04  * A simple class
05  *
06  * This is the long description for this class,
07  * which can span as many lines as needed. It is
08  * not required, whereas the short description is
09  * necessary.
10  *
11  * It can also span multiple paragraphs if the
12  * description merits that much verbiage.
13  *
 13  *
14  * @author Jason Lengstorf <[email protected]>
15  * @copyright 2010 Ennui Design
16  * @license http://www.php.net/license/3_01.txt PHP License 3.01
17  */
18 class SimpleClass
19 {
20   /**
21    * A public variable
22    *
23    * @var string stores data for the class
24    */
25   public $foo;
26  
27   /**
28    * Sets $foo to a new value upon class instantiation
29    *
30    * @param string $val a value required for the class
31    * @return void
32    */
33   public function __construct($val)
34   {
35       $this‐>foo = $val;
36   }
37  
38   /**
39    * Multiplies two integers
40    *
41    * Accepts a pair of integers and returns the
42    * product of the two.
43    *
44    * @param int $bat a number to be multiplied
45    * @param int $baz a number to be multiplied
46    * @return int the product of the two parameters
47    */
48   public function bar($bat, $baz)
49   {
50       return $bat * $baz;
51   }
52 }
53  
54 ?>

Once you scan the preceding class, the benefits of DocBlock are apparent:
everything is clearly defined so that the next developer can pick up the code and
never have to wonder what a snippet of code does or what it should contain.

Comparing Object­Oriented and Procedural
Code
There's not really a right and wrong way to write code. That being said, this section
outlines a strong argument for adopting an object­oriented approach in
software development, especially in large applications.

Reason 1: Ease of Implementation

"While it may be daunting at first, OOP actually
provides an easier approach to dealing with data."

While it may be daunting at first, OOP actually provides an easier approach to
dealing with data. Because an object can store data internally, variables don't need
to be passed from function to function to work properly.

Also, because multiple instances of the same class can exist simultaneously, dealing
with large data sets is infinitely easier. For instance, imagine you have two people's
information being processed in a file. They need names, occupations, and ages.

The Procedural Approach
Here's the procedural approach to our example:

01 <?php
02  
03 function changeJob($person, $newjob)
04 {
05   $person['job'] = $newjob; // Change the person's job
06   return $person;
07 }
08  
09 function happyBirthday($person)
10 {
11   ++$person['age']; // Add 1 to the person's age
12   return $person;
13 }
14  
15 $person1 = array(
16   'name' => 'Tom',
17   'job' => 'Button‐Pusher',
18   'age' => 34
19 );
20  
21 $person2 = array(
22   'name' => 'John',
23   'job' => 'Lever‐Puller',
24   'age' => 41
25 );
 );
26  
27 // Output the starting values for the people
28 echo "<pre>Person 1: ", print_r($person1, TRUE), "</pre>";
29 echo "<pre>Person 2: ", print_r($person2, TRUE), "</pre>";
30  
31 // Tom got a promotion and had a birthday
32 $person1 = changeJob($person1, 'Box‐Mover');
33 $person1 = happyBirthday($person1);
34  
35 // John just had a birthday
36 $person2 = happyBirthday($person2);
37  
38 // Output the new values for the people
39 echo "<pre>Person 1: ", print_r($person1, TRUE), "</pre>";
40 echo "<pre>Person 2: ", print_r($person2, TRUE), "</pre>";
41  
42 ?>

When executed, the code outputs the following:

01 Person 1: Array
02 (
03   [name] => Tom
04   [job] => Button‐Pusher
05   [age] => 34
06 )
07 Person 2: Array
08 (
09   [name] => John
10   [job] => Lever‐Puller
11   [age] => 41
12 )
13 Person 1: Array
14 (
15   [name] => Tom
16   [job] => Box‐Mover
17   [age] => 35
18 )
19 Person 2: Array
20 (
21   [name] => John
22   [job] => Lever‐Puller
23   [age] => 42
24 )

While this code isn't necessarily bad, there's a lot to keep in mind while coding. The
array of the affected person's attributes must be passed and returned from
each function call, which leaves margin for error.

To clean up this example, it would be desirable to leave as few things up to the
developer as possible. Only absolutely essential information for the current
operation should need to be passed to the functions.

This is where OOP steps in and helps you clean things up.

The OOP Approach
Here's the OOP approach to our example:

01 <?php
02  
03 class Person
04 {
05   private $_name;
06   private $_job;
07   private $_age;
08  
09   public function __construct($name, $job, $age)
10   {
11       $this‐>_name = $name;
12       $this‐>_job = $job;
13       $this‐>_age = $age;
14   }
15  
16   public function changeJob($newjob)
17   {
18       $this‐>_job = $newjob;
19   }
20  
21   public function happyBirthday()
22   {
23       ++$this‐>_age;
24   }
25 }
26  
27 // Create two new people
28 $person1 = new Person("Tom", "Button‐Pusher", 34);
29 $person2 = new Person("John", "Lever Puller", 41);
30  
31 // Output their starting point
32 echo "<pre>Person 1: ", print_r($person1, TRUE), "</pre>";
33 echo "<pre>Person 2: ", print_r($person2, TRUE), "</pre>";
34  
35 // Give Tom a promotion and a birthday
36 $person1‐>changeJob("Box‐Mover");
37 $person1‐>happyBirthday();
38  
39 // John just gets a year older
40 $person2‐>happyBirthday();
41  
42 // Output the ending values
43 echo "<pre>Person 1: ", print_r($person1, TRUE), "</pre>";
44 echo "<pre>Person 2: ", print_r($person2, TRUE), "</pre>";
45  
46 ?>
This outputs the following in the browser:

01 Person 1: Person Object
02 (
03   [_name:private] => Tom
04   [_job:private] => Button‐Pusher
05   [_age:private] => 34
06 )
07  
08 Person 2: Person Object
09 (
10   [_name:private] => John
11   [_job:private] => Lever Puller
12   [_age:private] => 41
13 )
14  
15 Person 1: Person Object
16 (
17   [_name:private] => Tom
18   [_job:private] => Box‐Mover
19   [_age:private] => 35
20 )
21  
22 Person 2: Person Object
23 (
24   [_name:private] => John
25   [_job:private] => Lever Puller
26   [_age:private] => 42
27 )

There's a little bit more setup involved to make the approach object oriented, but
after the class is defined, creating and modifying people is a breeze; a person's
information does not need to be passed or returned from methods, and only
absolutely essential information is passed to each method.

"OOP will significantly reduce your workload if
implemented properly."

On the small scale, this difference may not seem like much, but as your applications
grow in size, OOP will significantly reduce your workload if implemented properly.

Tip — Not everything needs to be object oriented. A quick function that handles
something small in one place inside the application does not necessarily need to be
wrapped in a class. Use your best judgment when deciding between object­oriented
and procedural approaches.
Reason 2: Better Organization

Another benefit of OOP is how well it lends itself to being easily packaged and
cataloged. Each class can generally be kept in its own separate file, and if a uniform
naming convention is used, accessing the classes is extremely simple.

Assume you've got an application with 150 classes that are called dynamically
through a controller file at the root of your application filesystem. All 150 classes
follow the naming convention  class.classname.inc.php  and reside in the  inc
folder of your application.

The controller can implement PHP's  __autoload()  function to dynamically pull in

only the classes it needs as they are called, rather than including all 150 in the
controller file just in case or coming up with some clever way of including the files in
your own code:

1 <?php
2   function __autoload($class_name)
3   {
4       include_once 'inc/class.' . $class_name . '.inc.php';
5   }
6 ?>

Having each class in a separate file also makes code more portable and easier to
reuse in new applications without a bunch of copying and pasting.

Reason 3: Easier Maintenance
Due to the more compact nature of OOP when done correctly, changes in the code
are usually much easier to spot and make than in a long spaghetti code
procedural implementation.

If a particular array of information gains a new attribute, a procedural piece of
software may require (in a worst­case scenario) that the new attribute be added to
each function that uses the array.

An OOP application could potentially be updated as easily adding the new property
and then adding the methods that deal with said property.

A lot of the benefits covered in this section are the product of OOP in combination
with DRY programming practices. It is definitely possible to create easy­to­
maintain procedural code that doesn't cause nightmares, and it is equally possible to
create awful object­oriented code. [Pro PHP and jQuery] will attempt to demonstrate
a combination of good coding habits in conjunction with OOP to generate clean code
that's easy to read and maintain.

Summary
At this point, you should feel comfortable with the object­oriented programming style.
Learning OOP is a great way to take your programming to that next level. When
implemented properly, OOP will help you produce easy­to­read, easy­to­maintain,
portable code that will save you (and the developers who work with you) hours of
extra work. Are you stuck on something that wasn't covered in this article? Are you
already using OOP and have some tips for beginners? Share them in the comments!

Author's Note — This tutorial was an excerpt from Pro PHP and jQuery (Apress,
2010).

Difficulty:
Intermediate
Length:
Long