Draft Only
Contents
- What is OOP
- What is an Object
- What is a class
- Commenting code
- Inheritance (Extending a class)
- Visibility (public, private, protected)
- Final
- Abstract Classes
- Static Methods and properities
- Interfaces
- PHP Class Functions
- Autoload
- Serializing Objects
- Overloading
- Class Constants
- Credits
OOP was first invented for the purpose of physical modelling in the Simula-67.
Whilst there is no hard and fast definition of what Object Oriented
Programming (OOP) is, we can define. So lets just use this loose
definition for now and it is left to reader to make up their own minds
about what a decent definition is. Object Oriented Programming (OOP) is
a programming concept that treats functions and data as objects. OK,
not the best definition but gives us an opening. The key word here is
objects. As we progress through this tutorial we will see how data and
functions can be represented as re-usable objects, thus cutting down on
code and time.
Simply put, an oject is a bunch of variables and functions all
lumped into a single entity. The object can then be called rather than
calling the variables or functions themselves. Within an object there
are methods and properties. The methods are functions that manipulate
data withing the object. The properties are variables that hold
information about the object.
A class is the blueprint for your object. The class contains the
methods and properties, or the charactaristics of the object. It
defines the object. Lets just start with some examples to see how it
all pieces together. We will use a vehicle as our object. All vehicles
share similar charactaristics, eg: number of doors, they are painted
some color, they each have a price. All vehicles do similar things
also, drive, turn left, turn right, stop etc. These can be described as
functions, or in OOP parlance, methods. So, the class holds the definition, and the object holds the value. You declare class in PHP by using the class keyword.
<?php
class vehicle{
/*** define public properties ***/
/*** the color of the vehicle ***/
public $color;
/*** the number of doors ***/
public $num_doors;
/*** the price of the vehicle ***/
public $price;
/*** the shape of the vehicle ***/
public $shape;
/*** the brand of vehicle ***/
public $brand;
/*** the constructor ***/
public function __construct(){
echo
'About this Vehicle.<br />';
}
/*** define some public methods ***/
/*** a method to show the vehicle price ***/
public function showPrice(){
echo
'This vehicle costs '.$this->price.'.<br />';
}
/*** a method to show the number of doors ***/
public function numDoors(){
echo
'This vehicle has '.$this->num_doors.' doors.<br />';
}
/*** method to drive the vehicle ***/
public function drive(){
echo
'VRRROOOOOOM!!!';
}
}
/*** end of class ***/
?> With this simple class definition we can now create one, or many,
vehicle objects. Lets see how its done, then we will step through it
all. To create a new object from the class definition we use the new keyword.
<?php
/*** create a new vehicle object ***/
$vehicle = new vehicle;
/*** the brand of vehicle ***/
$vehicle->brand = 'Porsche';
/*** the shape of vehicle ***/
$vehicle->shape = 'Coupe';
/*** the color of the vehicle ***/
$vehicle->color = 'Red';
/*** number of doors ***/
$vehicle->num_doors = 2;
/*** cost of the vehicle ***/
$vehicle->price = 100000;
/*** call the showPrice method ***/
$vehicle->showPrice();
/*** call the numDoors method ***/
$vehicle->numDoors();
/*** drive the vehicle ***/
$vehicle->drive();
?> Using the combination of the two code boxes above, you should have something like..
About this vehicle.
This vehicle costs 100000.
This vehicle has 2 doors.
Lets step through the class definition first to see what its all about.
We began the class with the class keyword. This tells PHP that what follows is a class definition.
<?php
class vehicle{
?>
Next we declared some variables, or as they are known in the OOP world, properties.
<?php
/*** the color of the vehicle ***/
public $color;
/*** the number of doors ***/
public $num_doors;
/*** the price of the vehicle ***/
public $price;
/*** the shape of the vehicle ***/
public $shape;
/*** the brand of vehicle ***/
public $brand;
?>
The properties are the individual charactaristics of the vehicle object. The public
declares that this property may be accessed within the public scope.
This means you may set it from within your code. Next in the class
definition is this code..
<?php
/*** the constructor ***/
public function __construct(){
echo
'About this vehicle.<br />';
}
?> The constructor method (function) is a special function that is
executed every time a new object is created or “instantiated”. If a
class needs to do something before running some code, then this is the
place to do it. It is often used to set properties within the class.
You may pass a variable directly to the constructor from your code, but
more of that later. Following the constructor is several methods
(functions) that do things. These methods are also preceded by the public meaning they are available with the scope of your code.
<?php
/*** a method to show the vehicle price ***/
public function showPrice(){
echo
'This vehicle costs '.$this->price.'.<br />';
}
/*** a method to show the number of doors ***/
public function numDoors(){
echo
'This vehicle has '.$this->num_doors.' doors.<br />';
}
/*** method to drive the vehicle ***/
public function drive(){
echo
'VRRROOOOOOM';
}
?> As you see above, our methods are similar to normal PHP functions.
However you may note the use of variables like $this->price and
$this->num_doors. The keyword $this is used to refer to properties or methods within the class itself. The $this
keyword is reserved in PHP, so it cannot be used as a variable or
property name. Finally we finished our class definition with a closing }. I like to put a comment beside it so I dont delete it or get it confused with a function I am writing.
Following on from the class definition we see our userland code.
This is the code we use to instantiate (create) a new instance, or new
object, of our vehicle class. As mentioned earlier we do this with the
use of the new keyword.
<?php
/*** create a new vehicle object ***/
$vehicle = new vehicle;
?>
The code above creates a new object from our class definition called $vehicle.
It is at this time that the constructor is called and any code within
the constructor is executed. Once we have a new object we can then
begin to assign values to the properties of that object as seen here.
<?php
/*** the brand of vehicle ***/
$vehicle->brand = 'Porsche';
/*** the shape of vehicle ***/
$vehicle->shape = 'Coupe';
/*** the color of the vehicle ***/
$vehicle->color = 'Red';
/*** number of doors ***/
$vehicle->num_doors = 2;
?>
With the properties set as above, it is now simple to use the object
methods to manipulate the object by calling the methods. The methods
are executed like this below.
<?php
/*** call the showPrice method ***/
$vehicle->showPrice();
/*** call the numDoors method ***/
$vehicle->numDoors();
/*** drive the vehicle ***/
$vehicle->drive();
?>
So, thats the step-by-step of your first class. You see how easy it
would be now to create a new car object. Perhaps a Red Ferrari with 4
doors costing $250,000.00.
In the previous sections you have seen comments for almost every
line of code. This is a good practice, although some may find it
excessive, as it may not be you who has to edit the code next time. OOP
can get very abstracted and if you are not careful it is easy to lose
site of your programmatical work flow. Most methods within a class will
return a value, rather than echo a line of HTML code. A class method
may also take one, or several, arguements. It is good practice to show
what these arguements are and there types. An example follows below.
<?php
/**
* adds an array of numbers and returns the value
*
* @param array $numbers An array of numbers to add
*
* @access private
*
* @return int Returns sum of numbers
*
*/
private function sum_of_numbers($numbers){
/*** return the sum of the $numbers array ***/
return array_sum($numbers);
}
?> The above function is rather simplistic, but shows well the
commenting of code. The comments begin in a block of C type multiline
comments and gives us a brief description of what it does, followed by
the parameter it takes, in this case an array of numbers. It tells us
that access to the function is private (more on this in the next
section). Finally the comment block tells us that the return value is
of type INT. We can also see within the function itself a single line
comment just to show what is happening within the funtion itself. If
you follow these practices you code will always be readable and easy to
follow by yourself and others.
Probably the greatest feature of the PHP OOP model is Inheritence.
Inheritence is the ability of php to extend classes (child classes)
that inherit the charactaristics of the parent class. The resulting
object of an extend class has all the charactaristics of the parent
class, plus whatever is in the new child, or extended class. In this
instance we will extend the vehicle class and add a motorcyle. A
motorcycle is still a vehicle and shares many of the same attributes
such as price, drive etc. But a motorcycle has some unique features
that a car does not.
Rather than type out the whole of the vehicle class definition
again, we will save it in a file of its own called vehicle.class.php.
It is important here to note the naming convention here as it will be
important later in this tutorial. Lets see how it works.
<?php
/*** include the vehicle class definition ***/
include('vehicle.class.php');
class
motorcycle extends vehicle{
/*** the number of side cars ***/
private $num_sidecars;
private
$handlebars;
/**
*
* set the type of handlebars
*
* @access public
*
* @param string
*
* @return string
*
**/
public function setHandlebars($handlebarType){
$this->handlebars=$handlebarType;
}
/**
*
* Set number of side cars
*
* @access public
*
* @param int
*
* @return int
*
**/
public function setSidecar($numSidecars){
$this->numSidecars = $numSidecars;
}
/**
*
* Show the numbers of sidecars
*
* @return string
*
**/
public function showSideCar(){
echo
'This motorcyle has '. $this->numSidecars.' sidecar<br />';
}
}
/*** end of class ***/
/*** our userland code ***/
/*** create a new vehicle object ***/
$vehicle = new motorcycle;
/*** the brand of vehicle ***/
$vehicle->brand = 'Harley Davidson';
/*** the shape of vehicle ***/
$vehicle->shape = 'Sportster';
/*** the color of the vehicle ***/
$vehicle->color = 'Black';
/*** number of doors ***/
$vehicle->num_doors = 0;
/*** cost of the vehicle ***/
$vehicle->price = 25000;
/*** type of handle bars ***/
$vehicle->setHandlebars('Ape Hangers');
/*** set the sidecar ***/
$vehicle->setSidecar(1);
/*** show the vehicle brand and type ***/
echo $vehicle->brand.': '.$vehicle->shape.'<br />';
/*** call the showPrice method ***/
$vehicle->showPrice();
/*** show the sidecars ***/
$vehicle->showSideCar();
/*** drive the vehicle ***/
$vehicle->drive();
?>
You see in the motorcycle class that we have used the keyword extends
to extend our vehicle class. We can then proceed to set vars in the
both the parent class and the child class. The child class has
inherited all the characaristics of the parent vehicle class.
If you run the above code with out including the parent class, you will get a Fatal Error like this:
Fatal error: Class ‘vehicle’ not found in /www/oop.php on line 3
You MUST include the class definition on *every page* when you store an object
This means when you use an object or wish to extend from it. you
must include the class file. Either as code, or most commonly, with an
include() statement.
The visibility of class members, (properties, methods), relates to
how that member may be manipulated within, or from outside the class.
Three levels of visibilty exist for class members.
By default, all class members are public. This means if you do not
declare a property or method within the class, it will be public. It is
good practice to declare the visibility of class members for the sake
of readability for yourself and others. It is much easier for another
programmer to see your intentions. This will also future proof your
scripts should access modifiers be deprecated.
Public class members (properties and methods) are available
through-out the script and may be accessed from outside the class as we
demonstrated in our car class. Lets create a simple new class to
demonstrate.
<?php
class mathematics{
/*** a number ***/
public $num;
/**
*
* Add two to a number
*
* @access public
*
* @return int
*
**/
public function addTwo(){
return
$this->num+2;
}
}
/*** end of class ***/
/*** Instantiate a new class instance ***/
$math = new mathematics;
/*** set the value of the number ***/
$math->num = 2;
/*** call the addTwo method ***/
echo $math->addTwo();
?> We can see in the above example that the public variable $num is set
from user space and we call a public method that adds two the number
and returns the value of $num+2. Having our properties (variables)
visible, or accessible from any part of our script works in our favour
here, but it can also work against us. A could arise if we lost track
of our values and changed the value of $num. To counter this problem we
can create a method to set the value for us. Even with this in place it
is still possible for somebody to simply access the $num variable. So
we make the variable private. This ensures us that the property is only
available within the class itself. It is private to the calling class.
Consider the following code.
<?php
class mathematics{
/*** a number ***/
private $num;
/**
*
* Set the value of $num
*
* @access public
*
* @param $num The number to set
*
* @return int
*
**/
public function setNum($num){
$this->num = $num;
}
/**
*
* Add two to a number
*
* @access public
*
* @return int
*
**/
public function addTwo(){
return
$this->num+2;
}
}
/*** end of class ***/
/*** Instantiate a new class instance ***/
$math = new mathematics;
/*** set the value of the number ***/
$math->setNum(2);
/*** call the addTwo method ***/
echo $math->addTwo();
?>
?>
Any further attempt to reset the $num property without the setNum() method would result in a Fatal Error such as
Fatal error: Cannot access private property mathematics::$num in /www/mathematics.class.php on line 43
Even if you were to try to access the private $num property from a
child class it would fail. This is because private methods and
properties in a parent class are not visible to child classes and
cannot be accessed. To access a parent method or property from a child
class you need to use the protected keyword. Like the
private keyword, protetected methods and properties are available only
to the class that created them. But unlike private, protected methods
and properties are visible from a parent class. Lets see how this works.
<?php
class mathematics{
/*** a number ***/
protected $num;
/**
*
* Set the value of $num
*
* @access public
*
* @param $num The number to set
*
* @return int
*
**/
public function setNum($num){
$this->num = $num;
}
/**
*
* Add two to a number
*
* @access public
*
* @return int
*
**/
public function addTwo(){
return
$this->num+2;
}
}
/*** end of class ***/
class divide extends mathematics{
/**
*
* Divide a number by two
*
* @access public
*
* @return int
*
**/
public function divideByTwo(){
/*** divide number by two ***/
$new_num = $this->num/2;
/*** return the new number and round to 2 decimal places ***/
return round($new_num, 2);
}
}
/*** end of class ***/
/*** Instantiate a new class instance ***/
$math = new divide;
/*** set the value of the number ***/
$math->setNum(14);
echo
$math->divideByTwo();
?> We can see here the the user space code has called the setNum()
method in the parent mathematics class. This method, in turn, sets the
$num property. We are able to do this because the $num property has
been declared protected and is visible to the child class.
As we saw in the previous section there are ways to protect your
code from being used in an improper manner. Another way of protecting
yourself is the Final keyword. Any method or class that
is declared as Final cannot be overridden or inherited by another
class. Lets put it to the test.
<?php
final class mathematics{
}
/*** end of class ***/
class divide extends mathematics{
}
?> By running the above code you will get an error such as
Fatal error: Class divide may not inherit from final class (mathematics) in /www/final.php on line 8
This can protect us from those who wish to use our code for a purpose other than that for which it was intended.
An abstract class is a class that cannot be instantiated on its own.
You cannot create a new object from it. To see this lets make a basic
class.
<?php
abstract class mathematics{
/**
*
* Add two to a number
*
* @access public
*
* @return int
*
**/
public function addTwo(){
return
$this->num+2;
}
}
/*** end of class ***/
/*** try to create new object from the mathematics class ***/
$math = new mathematics
?>
Using the code above, you will get an error something like this
Fatal error: Cannot instantiate abstract class mathematics in /www/abstract.php on line 23.
As you can see, this is not allowed. Also if you declare any class
method to be abstract, you must also declare the class itself as
abstract too. So, whats the point you ask? Well, you can inherit from
an abstract class. Any class that extends an abstract parent class must
create an interface of the parent abstract methods. If this is not done
a fatal error is generated. This ensures that the implementation is
correct.
<?php
abstract class mathematics{
/*** child class must define these methods ***/
abstract protected function getMessage();
abstract protected function
addTwo($num1);
/**
*
* method common to both classes
*
**/
public function showMessage() {
echo
$this->getMessage();
}
}
/*** end of class ***/
class myMath extends mathematics{
/**
*
* Prefix to the answer
*
* @return string
*
**/
protected function getMessage(){
return
"The anwser is: ";
}
/**
*
* add two to a number
*
* @access public
*
* @param $num1 A number to be added to
*
* @return int
*
**/
public function addTwo($num1) {
return
$num1+2;
}
}
/*** end of class ***/
/*** a new instance of myMath ***/
$myMath = new myMath;
/*** show the message ***/
$myMath->showMessage();
/*** do the math ***/
echo $myMath->addTwo(4);
?> The use of the static keyword allows class members
(methods and properties) to be used without needing to instantiate a
new instance of the class. The static declaratin must come after the
visibility declaration, eg:
public static myClass{
Because there is no object created when using a static call, the keyword $this and the arrow operator, ->
are not available. Static variables belong to the class itself and not
to any object of that class. To access withing the class itself you
need to use the self keyword along with the :: scope resolution operator. Lets whip up a quick example of using static.
<?php
/*** a simple class ***/
class myClass{
/*** a static variable ***/
static $foo;
}
/** give the static variable a value ***/
myClass::$foo = 'Bar';
/*** echo the static variable ***/
echo (myClass::$foo ).
?>
The above snippet will echo
Bar This is rather basic as an example, so lets use something
practical. Static properties are often used as counters. Here we will
use a basic counter class.
<?php
class counter{
/*** our count variable ***/
private static $count = 0;
/**
* Constructor, duh
**/
function __construct() {
self::$count++;
}
/**
*
* get the current count
*
* @access public
*
* @return int
*
**/
public static function getCount() {
return
self::$count;
}
}
/*** end of class ***/
/*** create a new instance ***/
$count = new counter();
/*** get the count ***/
echo counter::getCount() . '<br />';
/*** create another instance ***/
$next = new counter();
/*** echo the new count ***/
echo counter::getCount().'<br />';
/*** and a third instance ***/
$third = new counter;
echo
counter::getCount().'<br />';
?> Hopefully by the end of the above snippet you can see what is
happening. At each new instance the counter class we increment by one.
Not also the use of the :: scope resolution operator and self keyword to refer to the static variable within the class itself.
Interfaces in PHP allow you to define a common structure for your
classes. An interface cannot be instantiated on its own. One of the
goals of OOP is re-use of code. Interfaces make this a much easier
process. The interface methods have no internal logic, they are simply
a “mapping” or constraint of what the class, or classes, should
implement. Here we will demonstrate how this works using our vehicle
class from earlier, with the addition of a stop() function.
<?php
class vehicle implements testdrive{
/*** define public properties ***/
/*** the color of the vehicle ***/
public $color;
/*** the number of doors ***/
public $num_doors;
/*** the price of the vehicle ***/
public $price;
/*** the shape of the vehicle ***/
public $shape;
/*** the brand of vehicle ***/
public $brand;
/*** the constructor ***/
public function __construct(){
echo
'About this Vehicle.<br />';
}
/*** define some public methods ***/
/*** a method to show the vehicle price ***/
public function showPrice(){
echo
'This vehicle costs '.$this->price.'.<br />';
}
/*** a method to show the number of doors ***/
public function numDoors(){
echo
'This vehicle has '.$this->num_doors.' doors.<br />';
}
/*** method to drive the vehicle ***/
public function drive(){
echo
'VRRROOOOOOM!!!';
}
/**
* a method to stop the car
*
* @access public
*
**/
public function stop(){
echo
'SSSCCRRREEEEEECCHH!!!<br />';
}
}
/*** end of class ***/
/*** declare our interface ***/
interface testdrive{
/*** some functions that must be implemented ***/
function drive();
function
stop();
}
/*** an new vehicle object ***/
$object = new vehicle;
/*** call some methods ***/
$object->drive();
$object->stop();
?> You may of course create multiple classes to implement your
interface, but they will not inherit from each other. When you inherit
from a parent class, you may choose to override some of parent methods.
If you had multiple parent class methods with the same name, but
different functionality or charactaristics, PHP would have no way of
telling which of these methods to use. This is why multiple inheritance
does not work in PHP. In contrast, classes that implement an interface,
must implement every method so there is no ambiguity.
In the real world interfaces provide us with the tools harness parts
of multiple classes. Consider this scenario. If we had two classes, one
for a fax and the other for a printer. Each has seperate uses and could
be described like this:
<?php
class fax{
public function
dial();
public function
send();
public function
recieve();
}
class
printer{
public function
printBlack();
public function
printColor();
public function
printDraft();
}
?>
Both of the above classes give the required usage for each item, but
they do not take into consideration the existance of a printer/fax
machine. To get the usage of both classes we would do something like
this:
<?php
class fax{
public function
dial();
public function
send();
public function
recieve();
}
class
printer extends fax{
public function
printBlack();
public function
printColor();
public function
printDraft();
public function
kick();
}
class
printerFax extends fax{
}
$object = new printerFax;
?>
This code works by creating a stack of classes. The grandparent
class is fax. Then the printer class extends the fax class and inherits
all the methods from that class. This is where some problems may arise.
The printer class now has the function dial() available to it which is
clearly going to cause some confusion and possibly errors in logic.
To counter this problem an interface can be used to tell the classes
what functions (methods) are required. Lets look at the design.
<?php
interface fax{
public function
dial();
public function
send();
public function
recieve();
}
interface
printer{
public function
printBlack();
public function
printColor();
public function
printDraft();
public function
kick();
}
class
printerFax implements fax, printer{
public function
dial(){ }
public function
send(){ }
public function
recieve(){ }
public function
printBlack(){ }
public function
printColor(){ }
public function
printDraft(){ }
public function
kick(){ }
}
$object = new printerFax;
?>
Before we go further, it is recommended you run the above code. It
will produce no output but we need to be sure all is well. Having run
the code, remove the line
public function kick(){ }
and run it again. What you should now get is an error such as:
Fatal error: Class printerFax contains 1 abstract method and must
therefore be declared abstract or implement the remaining methods
(printer::kick) in /www/oop.php on line 22
With the kick() function removed from our implementation, we have
essentially broken the contract that says we will implement every
function (method) specified in the interface. We can gather these
functions fractionally from multiple classes, but we MUST have them all
or we will get errors such as the one above.
Interfaces play a major role in with SPL and it is recommend you
implement the interfaces from SPL and not just the class methods.
PHP has available several class functions to help you through the OOP mine field.
- get_declared_interfaces()
- class_exists()
- get_class()
- get_declared_classes()
Each of these is shown here beginning with the get_declared_interfaces().
This helper function provides an array of all the available declared interfaces.
<?php
interface fax{
public function
dial();
public function
send();
public function
recieve();
}
interface
printer{
public function
printBlack();
public function
printColor();
public function
printDraft();
public function
kick();
}
/*** our interface implementation ***/
class printerFax implements fax, printer{
public function
dial(){ }
public function
send(){ }
public function
recieve(){ }
public function
printBlack(){ }
public function
printColor(){ }
public function
printDraft(){ }
public function
kick(){ }
}
/*** create and printerfax object ***/
$object = new printerFax;
/*** get the declared interfaces ***/
foreach(get_declared_interfaces() as $key=>$interface)
{
echo
$key.' => '.$interface.'<br />';
}
?>
The above code should produce a list such as this:
- 0 => Traversable
- 1 => IteratorAggregate
- 2 => Iterator
- 3 => ArrayAccess
- 4 => Serializable
- 5 => RecursiveIterator
- 6 => OuterIterator
- 7 => SeekableIterator
- 8 => Countable
- 9 => SplObserver
- 10 => SplSubject
- 11 => Reflector
- 12 => fax
- 13 => printer
From the list above you can see the SPL interfaces available and at
the bottom is our fax and printer interfaces. The printerfax is not
listed as it is not an interface, rather it is an implentation of an
interface.
Here we will see three helper functions for our classes
- get_class()
- class_exists()
- get_declared_classes
<?php
/*** a pretend class ***/
class fax{
public function
dial(){ }
public function
send(){ }
public function
recieve(){ }
}
/*** another pretend class ***/
class printer{
public function
printBlack(){ }
public function
printColor(){ }
public function
printDraft(){ }
public function
kick(){ }
}
/*** create an instance of the fax class ***/
$foo = new fax;
/*** create an instance of the printer class ***/
$bar = new printer;
echo
'$foo is from the ' get_class($foo).' class<br />';
echo
class_exists("printer").'<br />';
echo
'Declared classes are:<br /> ';
foreach(
get_declared_classes() as $key=>$classname)
{
echo
$key.' -> '.$classname.'<br />';
}
?> The little snippet above will produce over one hundred available
classes, shortened here for the sake of sanity, such as these below.
Note our fax and printer classes at the bottom of the list.
- $foo is from the fax class
- 1
- 0 -> stdClass
- 1 -> Exception
- —8<— snip —
- 106 -> fax
- 107 -> printer
Earlier in this tutorial we stated that the class definition must be
included in every call to an object. This is commonly achieved with the
include() or require() functions such as below.
<?php
/*** include our class definitions ***/
include('classes/vehicle.class.php');
include(
'classes/motorcycle.class.php');
include(
'classes/printer.class.php');
include(
'classes/printer.class.php');
/*** instantiate a new vehicle class object ***/
$vehicle = new vehicle;
***
instantiate a new motorcycle class object ***/
$bike = new motorcycle;
***
instantiate a new printer class object ***/
$printer = new printer;
***
instantiate a new fax class object ***/
$fax = new fax;
?>
As you can see, this is quite cumbersome. The solution to this sort
of mess is __autoload(). The __autoload() function will internally
search out the class and load its definition. So the above block of
code could be reduced to this.
<?php
/*** Autoload class files ***/
function __autoload($class){
require(
'classes/' . strtolower($class) . '.class.php');
}
/*** instantiate a new vehicle class object ***/
$vehicle = new vehicle;
/*** instantiate a new motorcycle class object ***/
$bike = new motorcycle;
/*** instantiate a new printer class object ***/
$printer = new printer;
/*** instantiate a new fax class object ***/
$fax = new fax;
?>
Now we can load up as many class definitions as we like because they
will be autoloaded when we try to use a class that has not been
defined. This can save much coding and much searching for code. It is
important to remember the naming convention of your classes and class
files. Each class file should be named the same as the class definition
itself. eg: a class definition file named fax would have the filename
fax.class.php
The use of the strtolower() function assures compatibility of naming
conventions as windows machines fail to be case sensitive for filenames.
We have seen a lot of code above for the use of objects and how they
can save us time (and $$$) by re-using them. But what if we needed to
somehow store an object for later retrieval, perhaps in a database or
in a session variable? PHP has given us the serialize() function to
make this rather effortless. There are some limitations, but this can
be a very useful tool for applications. Lets see how it performs with a
little code.
<?php
/*** code here ***/
?>
Comes a time in every programmers life when…hmm
Overloading in PHP has caused much confusion for no real reason. PHP Overloading can be broken downinto two basic components
- Method overloading
- Property overloading
Simply put, Method Overloading is achieved by a special function named __call().
It is available as a sort of method wildcard for calls to undefined
methods within a class. This special function is only called when the
original method name does not exist. The __call() will only work when the class method you are trying to access does not exist. Lets take it for a spin..
<?php
class my_class{
public function
foo() {
return
"This is the foo function";
}
}
/*** end of class ***/
/*** create a new class object ***/
$obj = new my_class;
/*** call a non-existant method ***/
$obj->bar();
?>
Of course the above snippet of code will produce an error such as
Fatal error: Call to undefined method my_class::bar() in /www/overload.php on line 12
because we have called the bar() class method that does not exist.
Enter __call(). With the __call() function in place, PHP will try to
create the function and you have any code within the _call() method
that you like. The __call() method takes two arguements, the method
name, and the arguements. Your call to the undefined method may have
many arguements and these are returned in an array. Lets put it to the
test with two args.
<?php
class my_class{
public function
foo() {
return
"This is the foo function";
}
/*** __call() method with two args ***/
public function __call($method, $arg){
echo
$method.'<br />';
print_r($arg);
}
}
/*** end of class ***/
/*** create a new class object ***/
$obj = new my_class;
/*** call a non-existant method ***/
$obj->bar("arg1", "arg2");
?>
The above code will print the following
bar
Array ( [0] => arg1 [1] => arg2 ) The __call() method has
returned the method name that we called along with the array of args
passed to it.
Lets now look at we can dynimically manipulate or overload our data.
<?php
class readyGetSet {
/*** declare $item ***/
private $item = 'Skate Board';
/*** declare the price ***/
private $price = 100;
/*** our call function ***/
function __call($method, $arguments){
/*** set property and prefix ***/
$prefix = strtolower(substr($method, 0oops fundametnal, oops learn, PHP OOPS, PHP5 class
This entry was posted
on Monday, September 21st, 2009 at 1:06 pm and is filed under PHP, PHP Object Oriented, Php Classes.
You can follow any responses to this entry through the RSS 2.0 feed.
Both comments and pings are currently closed.
