Throughout the course of the previous section, I showed you how to declare a couple of public properties within a sample class in order to make them globally accessible. Assuming that you grasped how to achieve this, the next thing that I’m going to teach you will be how to build the same class, but this time I will define the respective properties as protected data members.

The signature of the pertinent “DataSaver” class will look like this:

// define 'DataSaver' class ( properties are defined protected)

class DataSaver{

protected $filePath;

protected $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

public function getFilePath(){

return $this->filePath;

}

// get data via an accessor

public function getData(){

return $this->data;

}

}

Obviously, the definition of the above “DataSaver” class is nearly identical to the one that you learned in the previous section, except now the respective “$data” and “$filePath” properties have been declared protected by preceding them with the “protected” keyword. But what does this mean in simple terms?

Well, by definition, any data member defined as “protected” within a PHP 5 class can only be accessed from inside the originating class, and from inside all the eventual subclasses. This implies that they’re no longer globally available.

Of course, this concept will be better understood by example. So, below I set up another code sample that demonstrates how the PHP interpreter triggers a fatal error when the protected class properties are wrongfully accessed in the global scope:

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();

// print value of protected properties

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

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

/* displays the following fatal error with the first property

Fatal error: Cannot access protected property DataSaver::$filePath in path/to/file/

*/

/* displays the following fatal error with the second property

Fatal error: Cannot access protected property DataSaver::$data in path/to/file/

*/

}

catch(Exception $e){

echo $e->getMessage();

exit();

}

Pretty simple to grasp, right? As you can see in the above example, the PHP 5 engine will fire up a fatal error each time a protected property is accessed from outside the originating class. This implements an effective restriction mechanism that can be applied to both properties and methods of a given class.

However, as I explained before, the properties in question can be accessed without any restrictions from inside the originating class. Therefore, in the last section of this tutorial I’m going to show you yet another practical example where this condition will be recreated for you.

To see how this final example will be developed, please click on the link below and keep reading.