Beginning Object Oriented Programming in PHP
In this tutorial you will explore OOP in a way that'll start you on the fast track to polished OOP skills.
Object-Oriented Programming (OOP) tutorials are generally bogged down with programming theory and large metaphysical words such as encapsulation, inheritance and abstraction. They attempt to explain things by comparing code samples to microwaves or automobiles, which only serves to confuse the reader more.
But even when all the hype and mystique that surrounds OOP has been stripped away, you'll find it is indeed a good thing. I won't list reasons why... I don't want this to be another cookie-cutter tutorial that only serves to confuse you. Instead, we'll explore OOP in a way that'll start you on the fast track to polished OOP skills. As you grow in confidence with your skills and begin to use them more in your projects, you'll most likely form your own list of benefits.
Beginning Object Oriented Programming in PHP - Objects - The Magic Box
Imagine a box. It can be any type of box you want: a small jewelry box, a large crate, wooden, plastic, tall and thin, Short and wide...
Next, imagine yourself placing something inside the box: a rock, a million dollars, your younger sibling...
Wouldn't it be convenient if we could walk up to the box and just ask it to tell us what's inside instead of opening it ourselves? Actually, we can!
$mybox = new Box("Jack");
echo $mybox->get_whats_inside();
?>
Here the variable $mybox represents our self-aware box (also known as an object) which will be built by new--the world's smallest engineering and construction team. We also want to place Jack inside the box when it is built. When we want to ask the box it's contents, we'll apply a special get_whats_inside function to $mybox.
The code won't run quite yet, though. We haven't supplied new with the directions for him and his team to construct our box and PHP doesn't know what the function get_whats_inside is supposed to do.
Beginning Object Oriented Programming in PHP - Classes
A class is technically defined as a representation of an abstract data type. In laymen's terms a class is a blueprint from which new will construct our box. It's made up of variables and functions that allow our box to be self-aware. With the blueprint, new can build our box exactly to our specifications.
class Box
{
var $contents;
function Box($contents) {
$this->contents = $contents;
}
function get_whats_inside() {
return $this->contents;
}
}
$mybox = new Box("Jack");
echo $mybox->get_whats_inside();
?>
A closer look at our blueprint shows it contains the variable $contents which is used to remember the contents of the box. It also contains two functions: Box and get_whats_inside.
When the box springs into existence, PHP will look for and execute the function with the same name as the class. That's why our first function has the same name as the class itself. The whole purpose of the Box function is to initialize the contents of the box.
The special variable $this is used to tell Box that contents is a variable that belongs to the whole class and not the function itself. The $contents variable only exists within the scope of the function Box. $this->contents is a variable which was defined as part of the overall class.
The function get_whats_inside returns the value stored in the class' contents variable, $this->contents.
When the entire script is executed the class Box is defined, new constructs a box and passes "Jack" to it's startup function. The initialization function, which has the same name as the class itself, accepts the value passed to it and stores it within the class's variable so that it's accessible to functions throughout the entire class.
Now we've got a nice, shiny new Jack in the Box.
To ask the box what it contains, the special get_whats_inside function was used. Functions defined in the class are known as methods; they act as a method for communicating with and manipulating the data within the box.
The nice thing about methods is that they allow us to separate all the class coding from our actual script.
We could save all of the class code in a separate file and then use include to import it into our script. Our scripts become more streamlined and, because we used descriptive names for our methods, anyone else reading our code can easily see our train-of-thought.
include("class.Box.php");
$mybox = new Box("Jack");
echo $mybox->get_whats_inside();
?>
Another benefit of methods is that it provides our box or whatever other objects we may build with a standard interface that anyone can use. We can share our classes with other programmers or even import them into our other scripts when the functionality they provide is needed.
include("class.Box.php");
$mybox = new Box("Suggestion");
echo $mybox->get_whats_inside();
?>
include("class.Box.php");
$mybox = new Box("Shoes");
echo $mybox->get_whats_inside();
?>
Beginning Object Oriented Programming in PHP - Extends
So far our example is only capable of telling us what its content is. We could add more methods to our class, but what if we were building extensions to someone else's class? We don't have to create an entirely new class to add new functionality... we can build a small extension class based on the original.
include("class.Box.php");
class ShoeBox extends Box
{
varr $size;
function ShoeBox($contents, $size) {
$this->contents = $contents;
$this->size = $size;
}
function get_shoe_size() {
return $this->size;
}
}
$mybox = new ShoeBox("Shoes", 10);
echo $mybox->get_whats_inside();
echo $mybox->get_shoe_size();
?>
With the extends keyword, our script now has access to a ShoeBox class which is based on our original Box class. ShoeBox has all of the same functionality as Box class but also has extra functions specific to a special kind of box.
The ability to write such modular additions to your code gives great flexibility in testing out new methods and saves time by reusing the same core code.
include("class.Box.php");
include("extentions.Shoe.php");
include("extentions.Suggestion.php");
include("extentions.Cardboard.php");
$mybox = new ShoeBox("Shoes", 10);
$mySuggestion = new SuggestionBox("Complaints");
$myCardboard = new CardboardBox('', "corrugated", "18in", "12in", "10in");
?>
