Geek Files » PHP5 Tutorials

PHP 5 Tutorial – Handling Exceptions in PHP5

admin — Thu, 14 Feb 2008 08:58:21 +0000

In this tutorial we will cover the following:

What is an exception?
The use of a try…catch block
Anatomy of PHP5 Exception class
Extending the Exception class
A note on unhanded exceptions

What is an exception?

An exception is a logical/system error that occurs during the normal execution of a script. The exception could either be raised by the system or the program itself it the exception cannot be handled and the caller script/function needs to be informed about the same.

The use of a try…catch block

PHP5 introduces the try…catch block to trap exceptions. Look at the example below.

 
try {
   check();
}
catch(Exception $e) {
   echo "Message : " . $e->getMessage();
   echo "Code : " . $e->getCode();
}
 
function check() {
   if(some error condition) {
      throw new Exception("Error String",Error Code);
   }
}

In the above example, the method check() is called between the try {} block. The try{} block is the area where you will place your code that could raise an exception. Below the try{} block is the catch() {} block. The catch block expects the Exception type of object as a parameter. Within the catch() {} block you will place your logic to either fix the issue or log the error.

In the function check(), we raise an Exception using the ‘throw’ keyword. The statement following ‘throw’ is the syntax of creating a new object of Exception type. The exception class accepts two parameters. The left parameter is a string that is the error message and the right parameter is the integer error code that you wish to assign to that error.

Anatomy of PHP5 Exception class

 
class Exception {
	protected $message;
	protected $code;
	protected $file;
	protected $line;
 
	private $string;
	private $trace;
 
	public function __construct($message = null, $code = 0);
	public function __toString();
 
	final public function getCode();
	final public function getMessage();
	final public function getFile();
	final public function getLine();
	final public function getTrace();
	final public function getTraceAsString();
	final private __clone();
}

In the above example, except for __construct and __toString(), no other method can be overridden as all other methods are ‘final’.

Related Reading:

PHP5 Tutorial – Creating a PHP5 Constructor __construct()

PHP5 Tutorial – Defining Attributes of a PHP5 Class

PHP5 Tutorial OOPS – PHP5 Class Access Specifiers – public, private and protected

PHP 5 Tutorial – Final Class and Methods

PHP5 Tutorial – Magic Methods – __toString() method

Extending the Exception class

You can also extend the exception class as follows:

 
class CustomerException extends Exception {
 
  public function __construct($message = null, $code = 0) {
 
    $t_message = "Exception raised in CustomerException ";
    $t_message .= "with message : " . $message;
 
    parent::__construct($t_message, $code);
 
    }
 
}
 
 
function testException() {
 
	throw new CustomerException("CustomerException has been raised",101);
 
}
 
try {
	testException();
}
catch(CustomerException $e) {
	echo "Error Message : " $e->getMessage();
	echo "Error Code : " $e->getCode();
}

Output:

Error Message : CustomerException has been raised
Error Code : 101

Related Reading:
PHP5 Tutorial – Inheritance

A note on unhanded exceptions

All un-handled exceptions are passed up the function stack order till the time either a try…catch block is not made available. If a try…catch block is unavailable it is passed to the PHP core and the program execution stops there.

Please feel free to write back for any clarification.

Subscribe to my free newsletter:

Related Posts on PHP5 Tutorial – Object Oriented Programming (OOPS)

PHP 5 Tutorial – Final Class and Methods

admin — Thu, 14 Feb 2008 06:41:17 +0000

In this PHP tutorial we will understand the following:

Meaning of Final Class
Meaning of Final Method
When to declare a class as final
When to declare a method as final

Meaning of Final Class

A final class is a class that cannot be extended. To declare a class as final, you need to prefix the ‘class’ keyword with ‘final’. Example below.

 
final class BaseClass {
   public function myMethod() {
      echo "BaseClass method called";
   }
}
 
//this will cause Compile error
class DerivedClass extends BaseClass {
   public function myMethod() {
      echo "DerivedClass method called";
   }
}
 
$c = new DerivedClass();
$c->myMethod();

In the above example, BaseClass is declared as final and hence cannot be extended (inherited). DerivedClass tries to extend from BaseClass and hence the compiler will throw a compile error.

Meaning of Final Method

A final method is a method that cannot be overridden. To declare a method as final, you need to prefix the function name with the ‘final’ keyword. Example below:

 
class BaseClass {
   final public function myMethod() {
      echo "BaseClass method called";
   }
}
 
class DerivedClass extends BaseClass {
   //this will cause Compile error
   public function myMethod() {
      echo "DerivedClass method called";
   }
}
 
$c = new DerivedClass();
$c->myMethod();

In the above example, DerivedClass extends from BaseClass. BaseClass has the method myMethod() declared as final and this cannot be overridden. In this case the compiler causes a compile error.

When to declare a class as final

You should declare a class as final when you think that you implementation of that class should not change in the derived class. You should do this mainly for Utility classes where you don’t want the behavior/implementation of your class to change.

When to declare a method as final

You should declare a class method as final when you think that the method you develop contains necessary functionality to support your application and any modification or change to the functionality can cause unexpected errors/bugs.

Please feel free to write back for any clarification.

Subscribe to my free newsletter:

Related Posts on PHP5 Tutorial – Object Oriented Programming (OOPS)

PHP 5 Tutorials – Static Data Members and Methods

admin — Tue, 12 Feb 2008 09:47:49 +0000

In this tutorial you will learn all about static data members and methods

Meaning of static data members
Meaning of static methods
Defining static data members in PHP5
Defining static methods in PHP5
Accessing static data members in PHP5
Accessing static methods in PHP5
Rules to keep in mind for static methods

Meaning of static data members

A data member that is commonly available to all objects of a class is called a static member. Unlike regular data members, static members share the memory space between all objects of the same class.

Meaning of static methods

A static method is a class method that can be called without creating an instance of a class. Such methods are useful when creating utility classes.

Defining static data members in PHP5

To define a static member in PHP5 you need to prefix the class member name with the keyword ‘static’. Look at the example below.

 
class Customer {
 
	private $first_name; // regular member
	static public $instance_count; //static data member
 
}

In the above example $instance_count is declared as a static data member

Defining static methods in PHP5

To define a static data methods in PHP5 you need to prefix the class method name with the keyword ‘static’. Look at the example below.

 
class Customer {
 
	public function getFirstName() {
		//body of method
	}
 
	static public function getInstanceCount() {
		//body of method
	}
}

In the above example getInstanceCount is declared as a static method

Accessing static data members in PHP5

A static member data can be accessed using the name of the class along with the scope resolution operator (::) i.e. you donâ€™t need to create an instance of that class

Look at the example below:

 
class Customer {
 
	static public $instance_count = 0; //static data member
 
	public function __construct() {
		Customer::$instance_count++;
	}
 
	public function __destruct() {
		Customer::$instance_count--;
	}
 
	public function getFirstName() {
		//body of method
	}
 
	static public function getInstanceCount() {
		//body of method
	}
}
 
$c1 = new Customer();
$c2 = new Customer();
 
echo Customer::$instance_count;

Output:
2

In the above example, $instance_count is a static data member. Every time a new object is created the constructor is executed and the $instance_count variable is incremented by one. To echo the value contained in $instance_count variable, we use the :: (scope resolution) operator.

Accessing static method in PHP5

A static method can be accessed using the name of the class along with the scope resolution operator (::) i.e. you donâ€™t need to create an instance of that class. However, you can also access it with an instance variable.

Look at the example below:

 
class Customer {
 
	static public $instance_count = 0; //static data member
 
	public function __construct() {
		Customer::$instance_count++;
	}
 
	public function __destruct() {
		Customer::$instance_count--;
	}
 
	public function getFirstName() {
		//body of method
	}
 
	static public function getInstanceCount() {
		return Customer::$instance_count;
	}
}
 
$c1 = new Customer();
$c2 = new Customer();
 
echo Customer::getInstanceCount(); //this is using the scope resolution operator
echo $c1->getInstanceCount(); //this is using the instance variable

Output:
2
2

Rules to keep in mind for static methods

A static method can only access static data members
A static method does not have access to the $this variable

Please feel free to write back for any clarification.

Subscribe to my newsletter:

Related Posts on PHP5 Tutorial – Object Oriented Programming (OOPS)

PHP5 OOPS Tutorials – Polymorphism

admin — Mon, 11 Feb 2008 07:09:09 +0000

In this tutorial we will learn the following:

Meaning of Polymorphism
Why method polymorphism cannot be achieved in PHP
PHP 5 Object Polymorphism

Meaning of Polymorphism

Polymorphism is derived from two Greek words. Poly (meaning many) and morph (meaning forms). Polymorphism means many forms. In C you have two methods with the same name that have different function signatures and hence by passing the correct function signature you can invoke the correct method.

This is how polymorphism is achieved in languages like C where in a function sum(int, int) differs from sum(float, float). Therefore the method sum() has many forms depending on the parameters being passed to it.

The meaning with Object Oriented languages changes. With Object Oriented language polymorphism happens:

When the decision to invoke a function call is made by inspecting the object at runtime it is called Polymorphism

Why method polymorphism cannot be achieved

The reason why polymorphism for methods is not possible in PHP is because you can have a method that accepts two parameters and call it by passing three parameters. This is because PHP is not strict and contains methods like func_num_args() and func_get_arg() to find the number of arguments passed and get a particular parameter.

Because PHP is not type strict and allows variable arguments, this is why method polymorphism is not possible.

PHP 5 Polymorphism

Since PHP 5 introduces the concept of Type Hinting, polymorphism is possible with class methods. The basis of polymorphism is Inheritance and overridden methods.

Lets look at an example:

 
class BaseClass {
   public function myMethod() {
      echo "BaseClass method called";
   }
}
 
class DerivedClass extends BaseClass {
   public function myMethod() {
      echo "DerivedClass method called";
   }
}
 
function processClass(BaseClass $c) {
   $c->myMethod();
}
 
$c = new DerivedClass();
processClass($c);

In the above example, object $c of class DerievedClass is executed and passed to the processClass() method. The parameter accepted in processClass() is that of BassClass. Within the processClass() the method myMethod() is being called. Since the method is being called on the class variable of BaseClass, it would not be wrong to assume that myMethod() of class BaseClass will be called. But, as per the definition “When the decision to invoke a function call is made by inspecting the object at runtime it is called Polymorphism”, myMethod() will be called on object DerievedClass. The reason why this happens is because the object of DerievedClass is being passed and hence the method myMethod() of DerievedClass will be called.

Please feel free to write back for any clarification.

Subscribe to my newsletter:

Related Posts on PHP5 Tutorial – Object Oriented Programming (OOPS)

PHP5 Tutorial – Defining Methods of a PHP5 Class

admin — Thu, 08 Nov 2007 14:41:43 +0000

In this PHP5 tutorial you will learn about methods and how to declare and use them in PHP5 class.

Definition of an class method
A class method/functions is the behavior/functionality of a class i.e. they provide the necessary code for the class in which it is defined. Examples could be a saveCustomer() method in the class Customer or a printDocument() in the Document class.

Methods act (perform operations) on the data members of the class and can be declared as private or public. A class method is exactly similar to PHP functions, it’s just that class functions are declared inside classes and accessed using the -> (arrow operator / dereferencing operator).

Methods can also be declared as either public, protected or private.

Lets look at an example to understand PHP5 Class methods better:

Example Code:

class Customer {
	private $name;
	public functionsetName($name) {
		$this->name = $name;
	}
}
 
$c1 = new Customer();
$c1->setName("Sunil Bhatia");

In the above example setName() is the class method of the Customer class. The setName() class method is responsible for accepting the name of the customer and storing it in the internal data member i.e. $name.

The reason why you require methods is so that you can perform necessary validations on the data passed. Let’s re-look at the above example with necessary validation code.

class Customer {
	private $name;
	public function setName($name) {
		if(trim($name) != "") {
			$this->name = $name;
			return true;
		}
		else {
			return false;
		}
	}
}
 
$c1 = new Customer();
$c1->setName("Sunil Bhatia");

In the above example the setName() method accepts a customer’s name and validates to check if $name is blank. If $name is blank the setName() function returns false; otherwise it stores the $name in the $this->name of the class and returns true.

Notes on Accessor and Mutator methods

Although we will learn about Access Specifiers in the subsequent tutorials; let’s try to understand the meaning and need for accessor and mutator methods.

Accessor Methods:
Accessor methods are also know as getter methods. The reason why we need an accessor method is to be able to read the value of a property/attribute in a class object. In real OOAD practice most of the data members that you define would either be private or protected (more on this will be covered in the tutorial on Access specifiers), therefore to access data of such data members that have been defined as either private or protected will require an implementation of accessor or getter methods.

Note: To make a property or data member as non-read only; you should not provide a getter or accessor method.

Mutator Methods:

Mutator methods are opposite to accessor methods. Mutator methods provides a mechanism to store data in data members that have either been declared as private or protected. The reason why you should provide a mutator method is to provide necessary validation on the data that is to be stored in the data member of the class.

Note: To make a property or data member as read only; you should not provide a setter or mutator method.

Lets look at an example of accessor and mutator methods below:

class Customer {
	private $name;
 
	//mutator method
	public function setName($name) {
		if(trim($name) != "") {
			$this->name = $name;
			return true;
		}
		else {
			return false;
		}
	}
 
	//accessor method
	public getName() {
		return $this->name;
	}
}
 
$c1 = new Customer();
$c1->setName("Sunil Bhatia");
echo $c1->getName();

Output:
Sunil Bhatia

In the above example the setName() method accepts a customer’s name and validates to check if $name is blank. If $name is blank the setName() function returns false; otherwise it stores the $name in the $this->name of the class and returns true. The getName() returns the name stored in the $name data member of the $c1 object.

In the next tutorial you will learn about PHP5 Constructor.

Feel free to write comments if you need more examples or if you need to ask a question on PHP5 Class. You can also subscribe to my notification service to be informed as an when a new tutorial article goes online. Subscribe Below

Related Posts on PHP5 Tutorial – Object Oriented Programming (OOPS)

PHP5 Tutorial – Magic Methods – __autoload() method

admin — Sat, 03 Nov 2007 09:34:31 +0000

This tutorial will teach you how and when to use the magic method __autoload().

The magic method __autoload() function is a convenience that allows you to use classes without having to explicitly write code to include them.

The magic method __autoload() is not included in your class definition as this is to be called once in a script. The best place to put the autoload() file is in your configuration file which is loaded in all your other scripts.

Many people debate that the magic method __autoload() causes a performance overhead. Well, that is not the case. There is no performance penalty to pay. In fact, there may be performance improvements if not all classes are used all the time. This is explained below.

Using the magic method __autoload has the beneficial side effect of requiring strict naming conventions for files that hold class definitions.

Look at the example below:

include â€œcustomer.phpâ€;
include â€œorders.phpâ€;
 
$c = new Customer();

In the example displayed above, an instance of class Customer is created. Therefore, we only need the customers.php file. The file orders.php is not needed. This means that we should only have included the customer.php file. But, what if during execution on the basis of a condition, an instance of class Orders would have to be created. Therefore you need to include both the files i.e. customer.php and orders.php

But this causes performance issues. Each time the above script is executed, orders.php is included. To avoid this performance hit, we would have to do additional programming to ensure that the file orders.php is loaded only when needed.

This is the reason why magic method __autoload() should be used. Look at the example below:

function __autoload($class) {
   require $class . '.php'; //is substituted as require Customer.php (with capital 'C')
}
 
$c = new Customer();

In the above program, we don’t explicitly include customer.php and orders.php file. When an instance of the customer class is to be created, the PHP engine checks to see if the file Customer.php is loaded. It does not raise an warning on finding that Customer.php has not been loaded, it in turn calls the magic method __autoload(). The __autoload() magic method accepts a parameter which is the name of the class that needs to be loaded.

Therefore, on the line when an instance of the customer class is created i.e. object $c, magic method __autoload() is called with the parameter $class containing value ‘Customer’. Within the __autoload() method we call the ‘require’ method. The require method tries to load $class.’php’ file i.e. Customer.php. Therefore, as stated earlier, the __autoload() method has its beneficial side effect of requiring strict file naming convention.

The __autoload() method is called only once for each new class that needs to be loaded. Subsequent instantiation of the Customer class object will not call the __autoload() method again. Therefore, this offers performance improvements in your scripts because, unless the class is needed – files are not loaded. Therefore, the PHP engine does not have to parse and compile an unnecessary file.

Please feel free to leave behind any comments or questions that you might have.

Related Posts on PHP5 Tutorial – Object Oriented Programming (OOPS)