If you found it easy to learn how to declare and implement protected methods using the "DataSaver" class, then I'm pretty sure that there will be a big smile on your face when I teach you how to work with private ones!

Well, I possibly got caught in the moment, but trust me, defining private methods in PHP 5 is a really simple process that only requires preceding the method that you wish to declare private with the "private" keyword. It's simple and intuitive, isn't it?

Besides, it's important to say that any method defined as private can only be called from inside the originating class. Period. In this case, it can't be accessed by any subclass, which restricts a method even more from unwanted calls.

Even so, the previous explanation would be rather incomplete if I didn't show you an example of how useful a private method can be in concrete situations. So, once more I'm going to appeal to the sample "DataSaver" class to show you how to declare and implement a pair of private methods.

This being said, take a look at the code sample below, which includes the modified signature of this sample class and shows how the PHP engine throws a fatal error when one of these methods is called in the global scope:

// define 'DataSaver' class (methods are defined private)

class DataSaver{

private $filePath;

private $data;

public function __construct($data,$filePath){

if(!$data||strlen($data)>1024){

throw new Exception('Invalid data for being saved to target file.');

}

if(!file_exists($filePath)){

throw new Exception('Invalid target file.');

}

$this->data=$data;

$this->filePath=$filePath;

}

// save data to target file

public function save(){

if(!$fp=fopen($this->filePath,'w')){

throw new Exception('Error opening target file.');

}

if(!fwrite($fp,$this->data)){

throw new Exception('Error writing data to target file.');

}

fclose($fp);

}

// get target file via an accessor

private function getFilePath(){

return $this->filePath;

}

// get data via an accessor

private function getData(){

return $this->data;

}

}

try{

// create new instance of 'DataSaver' class

$dataSaver=new DataSaver('This string of data will be saved to a target file!','datafile.txt');

// save data to target file

$dataSaver->save();

// call private methods

echo 'Target file is the following : '.$dataSaver->getFilePath().'<br />';

echo 'Data for being saved to target files is the following : '.$dataSaver->getData();

/* displays the following

Fatal error: Call to private method DataSaver::getFilePath() from context '' in path/to/file/

*/

}

catch(Exception $e){

echo $e->getMessage();

exit();

}

Didn't I tell you that using private methods with the above data saving class was going to be a straightforward process? And certainly, I was correct, since the previous example shows you very clearly how the PHP interpreter fires up a fatal error when a private method is directly called from outside the class in question.

With the previous example at your disposal, you can hopefully learn the basics of defining and implementing private methods within a basic PHP 5 class. So, what's the next step to take from here? Well, it's probable that you're wondering how a private method can be called in the global scope without getting a fatal error.

In practical terms, this isn't possible. However, there's something that can be done to skip over this restriction, and it consists of simply using a public method to access a private one. Indeed, this idea may sound confusing, but it can be used to expand your recently-acquired background in working with private methods.

Thus, in the section to come, I'm going to set up a final example for you that will recreate this particular situation.

Please, click on the link below and keep reading.