PHP 5 Power Programming

3.4 THE new KEYWORD AND CONSTRUCTORS
Instances of classes are created using the new keyword. In the previous example,
we created a new instance of the Person class using $judy = new Person();. What
happens during the new call is that a new object is allocated with its own copies
of the properties defined in the class you requested, and then the constructor of
the object is called in case one was defined. (more…)

3.3 DECLARING A CLASS
You might have noticed from the previous example that declaring a class (an
object template) is simple. You use the class keyword, give the class a name,
and list all the methods and properties an instance of this class should have:
class MyClass {
… // List of methods
…
… // List of properties
…
}
You may have noticed that, in front of the declaration of the $name prop-
erty, we used the private keyword. We explain this keyword in detail later, but
it basically means that only methods in this class can access $name. It forces
anyone wanting to get/set this property to use the getName() and setName()
methods, which represent the class’s interface for use by other objects or
source code.

3.2 OBJECTS
The main difference in OOP as opposed to functional programming is that the
data and code are bundled together into one entity, which is known as an
object. Object-oriented applications are usually split up into a number of
objects that interact with each other. Each object is usually an entity of the
problem, which is self-contained and has a bunch of properties and methods.
The properties are the object’s data, which basically means the variables that
belong to the object. The methods–if you are coming from a functional back-
ground–are basically the functions that the object supports. Going one step
further, the functionality that is intended for other objects to be accessed and
used during interaction is called an object’s interface.

A class is a template for an object and
describes what methods and properties an object of this type will have. In this
example, the class represents a person. For each person in your application,
you can make a separate instance of this class that represents the person’s
information. For example, if two people in our application are called Joe and
Judy, we would create two separate instances of this class and would call the
setName() method of each with their names to initialize the variable holding
the person’s name, $name. The methods and members that other interacting
objects may use are a class’s contract. In this example, the person’s contracts
to the outside world are the two set and get methods, setName() and get-
Name().
class Person
Methods:
setName($name)
getName()
Properties:
$name
Fig. 3.1 Diagram of class Person.
The following PHP code defines the class, creates two instances of it, sets
the name of each instance appropriately, and prints the names:
class Person {
private $name;
function setName($name)
{
$this->name = $name;
}
function getName()
{
return $this->name;
}
};
$judy = new Person();
$judy->setName(”Judy”);
$joe = new Person();
$joe->setName(”Joe”);
print $judy->getName() . “\n”;
print $joe->getName(). “\n”;

3.1 INTRODUCTION
PHP 3 is the version that introduced support for object-oriented programming
(OOP). Although useable, the support was extremely simplistic and not very
much improved upon with the release of PHP 4, where backward compatibil-
ity was the main concern. (more…)