Object Oriented Concepts
Before we go in detail, lets define important terms related to Object
Oriented Programming.
Class − This is a programmer-defined data type, which includes local functions
as well as local data. You can think of a class as a template for making many
instances of the same kind (or class) of object.
Object − An individual instance of the data structure defined by a class. You
define a class once and then make many objects that belong to it. Objects are
also known as instance.
Member Variable − These are the variables defined inside a class. This data
will be invisible to the outside of the class and can be accessed via member
functions. These variables are called attribute of the object once an object is
created.
Member function − These are the function defined inside a class and are used
to access object data.
Inheritance − When a class is defined by inheriting existing function of a
parent class then it is called inheritance. Here child class will inherit all or few
member functions and variables of a parent class.
Parent class − A class that is inherited from by another class. This is also
called a base class or super class.
Child Class − A class that inherits from another class. This is also called a
subclass or derived class.
Polymorphism − This is an object oriented concept where same function can
be used for different purposes. For example function name will remain same but
it make take different number of arguments and can do different task.
Overloading − a type of polymorphism in which some or all of operators have
different implementations depending on the types of their arguments. Similarly
functions can also be overloaded with different implementation.
Data Abstraction − Any representation of data in which the implementation
details are hidden (abstracted).
Encapsulation − refers to a concept where we encapsulate all the data and
member functions together to form an object.
Constructor − refers to a special type of function which will be called
automatically whenever there is an object formation from a class.
Destructor − refers to a special type of function which will be called
automatically whenever an object is deleted or goes out of scope.
Defining PHP Classes
The general form for defining a new class in PHP is as follows −
<?php
class phpClass {
var $var1;
var $var2 = "constant string";
function myfunc ($arg1, $arg2) {
[..]
[..]
?>
Here is the description of each line −
The special form class, followed by the name of the class that you want to
define.
A set of braces enclosing any number of variable declarations and function
definitions.
Variable declarations start with the special form var, which is followed by a
conventional $ variable name; they may also have an initial assignment to a
constant value.
Function definitions look much like standalone PHP functions but are local to the
class and will be used to set and access object data.
Example
Here is an example which defines a class of Books type −
<?php
class Books {
/* Member variables */
var $price;
var $title;
/* Member functions */
function setPrice($par){
$this->price = $par;
function getPrice(){
echo $this->price ."<br/>";
function setTitle($par){
$this->title = $par;
function getTitle(){
echo $this->title ." <br/>";
}
?>
The variable $this is a special variable and it refers to the same object ie.
itself.
Creating Objects in PHP
Once you defined your class, then you can create as many objects as you
like of that class type. Following is an example of how to create object
using newoperator.
$physics = new Books;
$maths = new Books;
$chemistry = new Books;
Here we have created three objects and these objects are independent of
each other and they will have their existence separately. Next we will see
how to access member function and process member variables.
Constructor Functions
Constructor Functions are special type of functions which are called
automatically whenever an object is created. So we take full advantage of
this behaviour, by initializing many things through constructor functions.
PHP provides a special function called __construct() to define a
constructor. You can pass as many as arguments you like into the
constructor function.
Following example will create one constructor for Books class and it will
initialize price and title for the book at the time of object creation.
function __construct( $par1, $par2 ) {
$this->title = $par1;
$this->price = $par2;
}
Now we don't need to call set function separately to set price and title. We
can initialize these two member variables at the time of object creation
only. Check following example below −
$physics = new Books( "Physics for High School", 10 );
$maths = new Books ( "Advanced Chemistry", 15 );
$chemistry = new Books ("Algebra", 7 );
/* Get those set values */
$physics->getTitle();
$chemistry->getTitle();
$maths->getTitle();
$physics->getPrice();
$chemistry->getPrice();
$maths->getPrice();
This will produce the following result −
Physics for High School
Advanced Chemistry
Algebra
10
15
7
Destructor
Like a constructor function you can define a destructor function using
function __destruct(). You can release all the resources with-in a
destructor.
Inheritance
PHP class definitions can optionally inherit from a parent class definition by
using the extends clause. The syntax is as follows −
class Child extends Parent {
<definition body>
}
The effect of inheritance is that the child class (or subclass or derived class)
has the following characteristics −
Automatically has all the member variable declarations of the parent class.
Automatically has all the same member functions as the parent, which (by
default) will work the same way as those functions do in the parent.
Following example inherit Books class and adds more functionality based on
the requirement.
class Novel extends Books {
var $publisher;
function setPublisher($par){
$this->publisher = $par;
function getPublisher(){
echo $this->publisher. "<br />";
Now apart from inherited functions, class Novel keeps two additional
member functions.
