Geek Files » PHP 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 Tutorial – Inheritance in PHP5

admin — Thu, 15 Nov 2007 05:21:50 +0000

In the tutorial we will understand what is Inheritance in general and how to inherit classes in PHP5.

Definition of Inheritance:

Inheritance is the mechanism of deriving a new class from an existing class. It allows a sub-class / child class to share/inherit the attributes and behaviors of a base-class or parent class. These inherited attributes and behaviors are usually modified by means of extension.

PHP5 Inheritance

To inherit in PHP5, you should use the keyword ‘extends’ in the class definition. In PHP5 only single inheritance is allowed. Look at the example below:

class Person {
	private $name;
	private $address;
 
	public function getName() {
		return $this->name;
	}
}
 
class Customer extends Person {
	private $customer_id;
	private $record_date;
 
	public getCustomerId() {
		return $this->customer_id;
	}
 
	public getCustomerName() {
		return $this->getName();// getName() is in Person
	}
}

In the above example, class Customer extends from the Person class. This means that Customer class is the child class and the Person base class. The child class Customer extends the method getName() and calls it in the getCustomerName() method of the Customer class.

Inheritance and Access Specifiers
You can refer to the Access specifiers tutorial to understand what it means. Let’s understand the use of Access Specifiers with context to Inheritance.

Access specifiers specify the level of access that the outside world (other objects and functions) have on the data members / member functions of the class. Please note that all data members and member functions are public by default.

Lets look at how three access specifiers viz. private, public and protected behave in Inheritance:

1. private

A private access specifier is used to hide data and member functions. A method or data member declared as private can only be accessed by the class itself and neither the outside program nor the derived class can have access to it. Lets look at an example below:

class Customer {
	private $name;
	public $age;
 
	public function __construct($name, $age) {
		$this->name = $name;
		$this->age = $age;
	}
}
 
$c = new Customer("Sunil","28");
echo "Name : " . $c->name; //causes an error

In the above example, the statement;

echo “Name : ” . $c->name;

causes an error as we are trying to access $name that has been declared as a private member variable. We can however access the $age data member without any limitation as its public. We will learn more about public later in this tutorial.

The reason why data members are declared private is to avoid the outside programs to either accidently modify the values without necessary validation. If you make a data member private you should provide accessor/mutator methods to access. Read more about accessor/mutator methods here (You will have to scroll a bit down and reach to “Notes on Accessor and Mutator methods”)

Note: When you define a method as private that method can only be called from within that class and not from outside that is the global level script.

2. public

A public access specifier allows the data members and methods to be access from anywhere in the script. Lets look at an example below:

class Customer {
	private $name;
	public $age;
 
	public function __construct($name, $age) {
		$this->name = $name;
		$this->age = $age;
	}
}
 
$c = new Customer("Sunil","28");
echo "Age : " . $c->age; //prints 28

In the above example, the statement;

echo “Age : ” . $c->;age;

prints 28 on the screen as $age is a public variable and hence can be accessed from anywhere in the script. Please note that if you declare any data member or method without a access specifier it is considered as ‘public’.

3. protected

A protected access specifier allows the derived class to access the data member or member functions of the base class, whereas disallows global access to other objects and functions.

class Person {
	protected $name;
}
 
class Customer extends Person {
	function setName($name) {
		//this works as $name is protected in Person
		$this->name = $name;
	}
}
 
$c1 = new Customer();
$c1->setName("Sunil");
$c1->name = "Sunil"; //this causes error as $name is protected and not public

In the above example, the statement;

$this->name = $name;

in the setName() function is referring to the $name data member of the Person class. This access is only possible because the $name variable has been declared as protected. Had this been private; the above statement would have raised an error. Further, in the statement towards the end;

$c1->name = “Sunil”;

raises an error as $name in the Person class has been declared as protected and not public.

PHP5 Inheritance – Method Overriding
Lets learn how to override methods in PHP5, but before we understand how to override methods in PHP5; lets define method overriding.

Definition of Method Overriding:
Method overriding is when the function of base class is re-defined with the same name, function signature and access specifier (either public or protected) of the derived class.

The reason to override method is to provide additional functionality over and above what has been defined in the base class. Imagine that you have a class by the name of Bird from which you derive two child classes viz. Eagle and Swift. The Bird class has methods defined to eat, fly, etc, but each of the specialized classes viz Eagle and Swift will have its own style of flying and hence would need to override the flying functionality.

Lets look at an example with Bird:

class Bird {
	public function fly() {
		echo "Fly method of Bird Class called";
	}
}
 
class Eagle extends Bird {
	public function fly() {
		echo "Fly method of the Eagle Class called";
	}
}
 
class Swift extends Bird {
	public function fly() {
		echo "Fly method of the Swift Class called";
	}
}
 
$e = new Eagle();
$s = new Swift();
 
$e->fly();
echo "\n";
$s->fly();

Output:
Fly method of the Eagle Class called
Fly method of the Swift Class called

In the above example, we create two objects of class Eagle and Swift. Each of these classes have overridden the method fly() and have provided their own implementation of the fly() method that has been extended from the Bird class. The manner in which they have been extended the Bird class fly() method is not called as both these classes have provided a new functionality for the fly() method.

Another example of function overriding in Inheritance

class Person {
	function calculateAge($dob) {
		echo "calculateAge called of Person Class\n";
	}
 
}
 
class Customer extends Person {
	function calculateAge($dob) {
		echo "calculateAge called of Customer Class\n";
	}
}
 
$c1 = new Customer();
$p1 = new Person();
 
$c1->calculateAge("something");
$p1->calculateAge("something More");

Output:
calculateAge called of Customer Class
calculateAge called of Person Class

PHP5 Inheritance – Invoking parent methods
When you override a method of the base class, it’s functionality is completely hidden unless it has been explicitly invoked from the child class. To invoke a parent class method you should use the keyword parent followed by the scope resolution operator followed by the name of the method as mentioned below:

	parent::function_name();

Look at the example below:

class Person {
	public function showData() {
		echo "This is Person's showData()\n";
	}
}
 
class Customer extends Person{
	public function showData() {
		parent::showData();
		echo "This is Customer's showData()\n";
	}
}
 
$c = new Customer();
$c->showData();

Output:
This is Person’s showData()
This is Customer’s showData()

In the above example, look at the way in which the showData() function in the Customer child class is invoking the the Person parent class’s showData() function. When the program executes the showData() method if the Customer class is called which inturn calls the showData() function of the parent class. After the parent class’s showData() function complets its execution the remaining code in showData() function of the Customer class is executed.

PHP5 Inheritance – Invoking parent Constructor and Destructor
We can get the parent PHP5 constructor and PHP5 Destructor to be invoked in the same way as invoking the parent method, refer to the example below:

class Person{
	public function __construct() {
		echo "This is Person's __construct()\n";
	}
 
	public function __destruct() {
		echo "This is Person's __destruct()\n";
	}
}
 
class Customer extends Person{
	public function __construct() {
		parent::__construct();
		echo "This is Customer's __construct()\n";
	}
 
	public function __destruct() {
		parent::__destruct();
		echo "This is Customer's __destruct()\n";
	}
}
 
$c = new Customer();

Output:
This is Person’s __construct()
This is Customer’s __construct()
This is Person’s __destruct()
This is Customer’s __destruct()

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

PHP5 Tutorial – Defining Class Constants

admin — Thu, 15 Nov 2007 04:46:36 +0000

In PHP4 the only constants that we would declare were global constants. In PHP5 it is possible to define a class level constant. These constants are specific to the class and hence don’t clutter the global level constant space.

To declare a constant in a class, PHP5 provides developers with a new keyword i.e. const; look at the example below:

class Customer {
	const TYPES = "Anything";
}
 
echo "Types are : " . Customer::TYPES;

In the above example, const is a keyword and TYPES is the name of the constant. Outside the class definition we echo the value of the constant by using the scope resolution operator (::) like this Customer::TYPES. Observe that we don’t need to create an object of the class to make use of the constant.

The next logical question is if we can create an object of the Customer class and using the scope resolution operator access the constant. The answer is no; reason – because a constant belongs to the class definition scope and not to an object.
Example of accessing Constants within a function

class Customer {
	const TYPES = "Anything";
 
	public function showConstant() {
		echo "Echo from showConstant() : " . Customer::TYPES;
	}
 
}
 
$c = new Customer();
$c->showConstant();

Output:
Echo from showConstant() : Anything

Some observations on Constants

Variables defined as constants cannot be changed.
Only a string or numeric value can be assigned to a constant.
Arrays, Objects & Expressions cannot be assigned to a constant.
A class constant can only be accessed via the scope resolution operator (::) executed on the class name.
A class constant cannot have access specifiers assigned to it (private, public & protected)

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

PHP5 Tutorial – instanceOf Operator Explained

admin — Thu, 15 Nov 2007 03:52:46 +0000

PHP5 introduces a new operator by the name of instanceOf. instanceOf is used to check if two objects passed as operands belong to the same class. This check can also happen when an object is compared with a class name.

In PHP4 a similar functionality existed with a method is_a(), which has been replaced by the instanceOf operator in PHP5.

Lets look at an example below:

class Person {
	...
}
 
$p1 = new Person();
$p2 = new Person();
 
if($p1 instanceof $p2)
    echo "True";
else
    echo "False";

In the above example, we are comparing to check if $p1 and $p2 belong to the same class i.e. Person. In this case $p1 and $p2 both belong to the same class Person and hence the output is True. Please note that line number 8 can also be written as if($p2 instanceof $p1) and will yield the same output.

You can also use instanceOf operator to compare an object with the name of the class, look at the example below:

class Person {
	...
}
 
$p1 = new Person();
 
if($p1 instanceof Person)
    echo "True";
else
    echo "False";

In the above example, on line number 7 $p1 object is being compared to check if its a Person type of object. In this case $p1 is a Person type of object and hence the output is True.

Behaviour of instanceOf operator in inheritance

class Customer extends Person {
	...
}
 
$p1 = new Person();
$c1 = new Customer();
 
if($c1 instanceof $p1)
    echo "True";
else
    echo "False";

In the above example, on line number 8 $c1 child class object is being compared with $p1 which is a parent class object. This is possible because Customer class is a child of the Person Class, just that the Customer class is a specialized form of the Person class and therefore this becomes possible. However the reverse is not possible, we cannot compare if($p1 instanceof $c1) and will result in an error.

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

PHP5 Tutorial – $this variable explained

admin — Wed, 14 Nov 2007 15:17:53 +0000

$this variable is a pointer to the object making the function call. $this variable is not avialable in static methods. We will learn more about static methods in the next series of tutorials.

Example:

class Customer {
 
   private $name;
 
   public setName($name) {
	$this->name = $name;
   }
 
}
 
$c1 = new Customer();
$c2 = new Customer();
 
$c1->setName(â€œSunilâ€);
$c2->setName(â€œVishalâ€);

In the above example, $c1 and $c2 are two separate Customer objects. Each object has its own memory to store names. But if you see the function setName() is common. During run time, how can it make a difference as to which memory location to use to store the function values. Therefore, it uses the $this variable. As mentioned earlier, $this variable is a pointer to the object making a function call. Therefore when we execute $c1->setName(“Sunil”), $this in the setName() function is a pointer or a reference to the $c1 variable.

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

Stack Implementation in PHP5 – Stack Class

admin — Tue, 13 Nov 2007 20:47:41 +0000

Refer to the code below which is a PHP5 Stack Class – an implementation of Stacks. You are free to use it in your programs.

class Stack {
 
	private $stk = array();
 
	public function __construct() {
	}
 
	public function push($data) {
		array_push($this->stk, $data);
	}
 
	public function pop() {
		return array_pop($this->stk);
	}
 
}
 
$s = new Stack();
 
$s->push("Sunil");
$s->push("Bhatia");
 
echo $s->pop();
echo "\n";
echo $s->pop();

Please fee free to leave comments if you have any questions or suggestions. Also don’t forget to subscribe to the newsletter – to keep yourself updated as and when new posts are made live. Subscribe Below:

PHP5 Tutorial – Object Oriented Programming (OOPS)

PHP5 Tutorial – Function – Method Type Hinting in PHP5

admin — Tue, 13 Nov 2007 19:11:36 +0000

PHP5 Introduces Method Type Hinting. Type Hinting allows a function to force parameters to be objects of a particular class by specifying the name of the class in the function prototype.

Type Hinting is optional in all cases except catch block.

Look at the example below without Method Type Hinting

class Customer {
	...
}
 
class Order {
   public function myfunc($c)
   {
	...
   }
}
 
$o = new Order();
$o->myfunc(â€œany dataâ€);

In the above code on line number starting from 6 to 9, the method myfunc() accepts any type of parameter and on line 13 we pass it a string data. However, I as the designer of the class wanted the developer to pass a Customer type of object to the function myfunc(), but because I did not specify the type in the function; any data can be passed. Method type hinting has been introduced to avoid such type issues.

Example of Method Type Hinting

class Customer {
	...
}
 
class Order {
   public function myfunc(Customer $c)
   {
	...
   }
}
 
$o = new Order();
$o->myfunc(â€œany dataâ€); //gives error as it expects Customer Object
 
$c = new Customer();
$o->myfunc($c); //works fine as $c is a Customer object

The above code is similar to the previous code, except that the only change is on line number 6. Take your time to compare the difference. The myfunc() now accepts a parameter of type Customer only. Therefore, line number 13 gives an error and line number 16 works well as $c is a customer object.

In the next PHP5 tutorial you will learn about the $this variable.

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)

All organizations want to hire skilled, knowledgeable, and competent professionals. If you are an IBM 000-974 certified or Microsoft 70-351 certified professional, you do not need to worry about job. Most job vacancies remain open for the Certified Information Systems Security Professional (CISSP) and Cisco 642-974 DCNIS professionals. Do not late, just enrolled yourself for HP0-J24 exam and secure your future today.

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

admin — Tue, 13 Nov 2007 19:02:44 +0000

In the earlier tutorials we have witnessed keywords like public, private and protected. These are nothing but access specifiers. So, lets understand what access specifiers are.

Definition of Access Specifiers
Access specifiers specify the level of access that the outside world (i.e. other class objects, external functions and global level code) have on the class methods and class data members. Access specifiers can either be public, private or protected.

Why do we need Access specifiers
Access specifiers are used as a key component of Encapsulation and Data Hiding. By using either of the access specifiers mentioned above i.e. public, private or protected you can hide or show the internals of your class to the outside world.

Explanation of each access specifier

1. Private
2. Protected
3. Public

1. Private
A private access specifier is used to hide the data member or member function to the outside world. This means that only the class that defines such data member and member functions have access them. Look at the example below:

class Customer {
	private $name;
 
	public function setName($name) {
		$this->name = $name;
	}
 
	public function getName() {
		return $this->name;
	}
}
 
$c = new Customer();
$c->setName("Sunil Bhatia");
echo $c->name; //error, $name cannot be accessed from outside the class
               //$name can only be accessed from within the class
 
echo $c->getName(); //this works, as the methods of the class have access
                    //to the private data members or methods

In the above example, echo $c->name will give you an error as $name in class Customer has been declared private and hence only be accessed by its member functions internally. Therefore, the following line echo $c->getName() will display the name.

2. Public
A public access specifier provides the least protection to the internal data members and member functions. A public access specifier allows the outside world to access/modify the data members directly unlike the private access specifier. Look at the example below:

class Customer {
	public $name;
 
	public function setName($name) {
		$this->name = $name;
	}
 
	public function getName() {
		return $this->name;
	}
}
 
$c = new Customer();
$c->setName("Sunil Bhatia");
echo $c->name;		// this will work as it is public.
$c->name = "New Name" ; // this does not give an error.

In the above example, echo $c->name will work as it has been declared as public and hence can be accessed by class member functions and the rest of the script.

3. Protected
A protected access specifier is mainly used with inheritance. A data member or member function declared as protected will be accessed by its class and its base class but not from the outside world (i.e. rest of the script). We can also say that a protected data member is public for the class that declares it and it’s child class; but is private for the rest of the program (outside world). Look at the example below:

 
class Customer {
	protected $name;
 
	public function setName($name) {
		$this->name = $name;
	}
 
	public function getName() {
		return $this->name;
	}
}
 
class DiscountCustomer extends Customer {
 
	private $discount;
 
	public function setData($name, $discount) {
		$this->name = $name; //this is storing $name to the Customer
				     //class $name variable. This works
				     // as it is a protected variable
 
		$this->discount = $discount;
	}
}
 
$dc = new DiscountCustomer();
$dc->setData("Sunil Bhatia",10);
echo $dc->name; // this does not work as $name is protected and hence
		// only available in Customer and DiscountCustomer class

In the above example, echo $dc->name will not work work $name has been defined as a protected variable and hence it is only available in Customer and DiscountCustomer class.

You will learn more about inheritance later in this tutorial series. You should revisit this tutorial and read more on the protected section again when you understand inheritance better.

Important Note of Access Specifier in PHP5
In PHP5, access specifiers are public by default. This means that if you don’t specify an access specifier for a data member or method then the default ‘public’ is applicable.

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