Special Methods

In this section, I will introduce a number of special methods that you can use within your classes. Although you have already been introduced to some of the special-use methods such as __construct(), __destruct(), and __clone(), a number of methods provide a great deal of functionality if used properly. To begin, let's look at the idea of getter and setter methods.

Getters and Setters

Getter and setter methods are methods that are used to provide a catch-all interface when accessing properties in objects. These methods, named __get() and __set() respectively, will be called when a particular property was not defined. The prototype for these special methods are as follows:

function __get($name);
function __set($name, $value);

In both instances, $name represents the name of the variable that the script attempted to access but that did not exist. As you might expect, the $value of the __set() method represents the new value attempting to be set to the nonexistent value.

NOTE Getter and setter methods are called only when the desired property does not exist in any way within the object. If the property initially does not exist but is then added to the instance via the set method (as shown below): function __set($name, $value) { $this->$name = $value; } neither the __get() or __set() methods will be called in the future.

Getter and setter methods are useful in situations, such as in dealing with Web services or container objects where the properties available within an instance of a class may not be completely known until the execution of the script.

The __call() Method

Like getters and setters, which enable you to dynamically handle property access within your PHP scripts, the __call() method is used to provide a catch-all for method calls within an object. When an attempt to call a method not previously defined within the class is received, if possible the __call method will be called. The prototype of this method is as follows:

function __call($method, $arguments);

$method is a string representing the name of the method that was called, and $arguments is an indexed array containing the parameters passed to the called method. Like getters and setters, the __call() method is useful when a complete function list is not available until the execution of the script. Alternatively, another application of the __call() method is to provide a catch-all method to handle attempts to call invalid methods in your PHP scripts, as shown in Listing 13.21:

Listing 13.21. Using the __call() Method

<?php
     class ParentClass {
          function __call($method, $params) {
               echo "The method $method doesn't exist!\n";
          }
     }
     class ChildClass extends ParentClass {
          function myFunction() {
               /* Function Logic */
          }
     }
     $inst = new ChildClass();
     $inst->nonExistentFunction();
?>

When Listing 13.21 is executed, an attempt will be made to call a method that is not defined. However, rather than causing a fatal error, the invalid call will trigger a call to the __call() method and allow you to handle the error cleanly.

The __toString() Method

The last special method I will be discussing in the new PHP 5 object model is the __toString() method. This method is designed to provide an easy way to access the string representation of a complex object. When defined, PHP will call this method under certain circumstances when the object would be better treated as a string (such as when it is displayed using echo or print statements). The value of the string returned by the __toString() method can be anything; however, it makes sense that it must somehow be representative of the object itself. Consider Listing 13.22, which implements the __toString() method and uses its functionality:

Listing 13.22. Using the __toString() Method

<?php
    class User {
            private $username;
            function __construct($name) {
                    $this->username = $name;
            }
            public function getUserName() {
                    return $this->username;
            }
            function __toString() {
                    return $this->getUserName();
            }
    }
    $user = new User("john");
    echo $user;
?>

In Listing 13.22, we have defined a simple class User that contains shell functionality for a simple User account class. This class contains a single private property, $username, which is available by calling the getUserName() method of the class. However, because this class also implements the __toString() method (which calls getUserName() itself), any instance of the class can be treated as a string directly, as shown by the echo statement. Although in this case the __toString() method was used in a fairly simplistic fashion, in a more complex object it can be effectively used to produce a string representation in any format desired.