PHP has some support for object-oriented programming. As shown below, it is possible to declare a class that has variables, constructors and functions.

Here is a file (called person.php) that declares a class called Person:

0510: <?php
0511:    class Person {
0512:       var $iName, $iAge;
0513:       function Person($pName, $pAge) {
0514:          $this->iName = $pName;
0515:          $this->iAge = $pAge;
0516:       }
0517:       function getName() {
0518:          return $this->iName;
0519:       }
0520:       function setName($pName) {
0521:          $this->iName = $pName;
0522:       }
0523:       function getAge() {
0524:          return $this->iAge;
0525:       }
0526:       function setAge($pAge) {
0527:          $this->iAge = $pAge;
0528:       }
0529:       function hasSameAge($pPerson) {
0530:          return $this->iAge==$pPerson->getAge();
0531:       }
0532:       function display() {
0533:          echo "<P>$this->iName's age is $this->iAge</P>\n";
0534:       }
0535:    }
0536: %>

And here is a file (called persontest.php) that declares and uses objects that are of this class:

0537: <?php
0538:    require("person.php");
0539:    // tom and dick
0540:    $tFirstPerson = new Person("tom", 25);
0541:    $tFirstPerson->display();
0542:    $tSecondPerson = new Person("dick", 24); 
0543:    $tSecondPerson->display();
0544:    $tSameAge = $tFirstPerson->hasSameAge($tSecondPerson);
0545:    if ($tSameAge)
0546:       echo "<P>they have the same age</P>\n";
0547:    else
0548:       echo "<P>they have different ages</P>\n";
0549:    // fred and barney
0550:    $tFirstPerson = new Person("fred", 55);
0551:    $tFirstPerson->display();
0552:    $tSecondPerson = new Person("barney", 55); 
0553:    $tSecondPerson->display();
0554:    $tSameAge = $tFirstPerson->hasSameAge($tSecondPerson);
0555:    if ($tSameAge)
0556:       echo "<P>they have the same age</P>\n";
0557:    else
0558:       echo "<P>they have different ages</P>\n";
0559: %>

Go to the script at: http://www.dur.ac.uk/barry.cornelius/papers/phpintro/code/persontest.php

Other possibilities include:

• using the :: symbol to access standalone functions of a class (called class methods in Java);
• using the extends symbol to derive a class from an existing class (single inheritance);
• using the parent:: symbols to access members of a superclass.

In a paper entitled 'The Object Oriented Evolution of PHP', Zeev Suraski explains some of the limitations of PHP 4 and outlines what is likely to be provided in PHP 5.

Some of the limitations of PHP 4 are:

• Objects are passed to functions by value and not by reference.
• There is no data encapsulation, i.e., a variable of a class cannot be made private to the class. So any client of the Person class can alter the $iName and $iAge variables themselves (and can ignore the setName and setAge functions):

  0560: $tFirstPerson->iAge = 24;
  

• Although you can access a class method, it is not possible to access class variables.
• There is no support for multiple inheritance.
• There are no constructs for exception handling (try/throw/catch).

Many of the above limitations are being removed in PHP 5. Beta 2 of PHP 5.0.0 has been released. Probably, the most up-to-date statement about the OO features of PHP 5 can be found at: http://www.php.net/zend-engine-2.php. Here is a summary of some of the new features in PHP 5:

• public, private and protected members (both variables and functions);
• interfaces, abstract classes and abstract methods;
• a final keyword for members (variables and functions) and for classes;
• PHP 5 also introduces:
  • a __clone function for cloning,
  • a __construct function for a constructor,
  • a __destruct function for a destructor,
  • a __toString function that allows overloading of object to string conversions;
• exception handling (that is similar to that of other programming languages).

Suraski's paper is at: http://www.zend.com/images/press/Feb_2003-4_Zeev_PHP5.pdf. Another useful paper is at: http://www.zend.com/engine2/ZendEngine-2.0.pdf