Object Oriented PHP for Beginners: Steps 12 - 17

Step 12:

Directly accessing properties - don't do it!

You don't have to use methods to access objects properties; you can directly get to them using the arrow operator (->) and the name of the variable.

For example: with the property $name (in object $stefan) you could get its value like so:

$name = $stefan->name;

Though doable, it is considered bad practice to do it because it can lead to trouble down the road. You should use getter methods instead - more on that later.

<?php include("class_lib.php"); ?>		
</head>		
<body>		
	<?php
		$stefan = new person();		
		$jimmy = new person;

		$stefan->set_name("Stefan Mischook");
		$jimmy->set_name("Nick Waddles");	
			
		// directly accessing properties in a class is a no-no.
		
		echo "Stefan's full name: ".$stefan->name;
		
	?>		
</body>
</html>

Step 13:

Constructors

All objects can have a special built-in method called a 'constructor'. Constructors allow you to initialise your object's properties (translation: give your properties values,) when you instantiate (create) an object.

Note: If you create a __construct() function (it is your choice,) PHP will automatically call the __construct() method/function when you create an object from your class.

The 'construct' method starts with two underscores (__) and the word 'construct'.

<?php 		
	class person {
		var $name;
		function __construct($persons_name) {		
			$this->name = $persons_name;		
		}		
		
		function set_name($new_name) {
		 	 $this->name = $new_name;
		}	
	
		function get_name() {		
		 	 return $this->name;		
		 }		

	}	 	
?>	 	
			

For the rest of this tutorial, I'm going to stop reminding you that:

  • Functions = methods
  • Variables = properties

Since this is an OO PHP tutorial, I will now use the OO terminology.

Step 14:

Create an object with a constructor

Now that we've created a constructor method, we can provide a value for the $name property when we create our person objects.

You 'feed' the constructor method by providing a list of arguments (like you do with a function) after the class name.

For example:

$stefan = new person("Stefan Mischook");

This saves us from having to call the set_name() method reducing the amount of code. Constructors are common and are used often in PHP, Java etc.

<?php include("class_lib.php"); ?>		
</head>		
<body>		
	<?php
		$stefan = new person("Stefan Mischook");
		echo "Stefan's full name: ".$stefan->get_name();
	?>		
</body>
</html>	 	

This is just a tiny example of how the mechanisms built into OO PHP can save you time and reduce the amount of code you need to write. Less code means less bugs.

Step 15:

Restricting access to properties using ' access modifiers '

One of the fundamental principles in OOP is 'encapsulation'. The idea is that you create cleaner better code, if you restrict access to the data structures (properties) in your objects.

You restrict access to class properties using something called 'access modifiers'. There are 3 access modifiers:

  1. public
  2. private
  3. protected

'Public' is the default modifier.

<?php 		
	class person {		
	var $name;		
		public $height;		
		protected $social_insurance;
		private $pinn_number;
		
		function __construct($persons_name) {		
			$this->name = $persons_name;		
		}		
		
		function set_name($new_name) {   	
			$this->name = $new_name;
		}	

		function get_name() {
			return $this->name;
		}		
			
	}
?>		

Note: When you declare a property with the 'var' keyword, it is considered 'public'.

Step 16:

Restricting access to properties: part 2

When you declare a property as 'private', only the same class can access the property.

When a property is declared 'protected', only the same class and classes derived from that class can access the property - this has to do with inheritance …more on that later.

Properties declared as 'public' have no access restrictions, meaning anyone can access them.

To help you understand this (probably) foggy aspect of OOP, try out the following code and watch how PHP reacts. Tip: read the comments in the code for more information:

<?php include("class_lib.php"); ?>  
</head>  
<body>
	<?php  
		$stefan = new person("Stefan Mischook");   
		echo "Stefan's full name: " .  $stefan->get_name() ;  

		/*  
		Since $pinn_number was declared private, this line of code 
		will generate an error. Try it out!   
		*/  
		
		echo "Tell me private stuff: ".$stefan->pinn_number;  
	?>  
</body>  
</html>   

Note: If you try to access a private property/variable outside of the class, you will get this:

'Fatal error: Cannot access private property person::$pinn_number
in ...' 

Step 17:

Restricting access to methods

Like properties, you can control access to methods using one of the three access modifiers:

  1. public
  2. protected
  3. private

Why do we have access modifiers?

In a nutshell: it comes down to control -it is makes sense to control how people use classes.

The reasons for access modifiers and other OO constructs, can be tricky to understand … especially since we are just beginners here. So give yourself a chance!

That said, we can (summarize and) say that many OOP constructs exist with idea the many programmers may be working together on a project.

<?php
	class person {  
		var $name;  

		public $height;  
		protected $social_insurance;  
		private $pinn_number;
		     
		function __construct($persons_name){   
		   $this->name = $persons_name;  
		}       
 
		private function get_pinn_number(){
			return
			$this->pinn_number;  
		}       
	}   
?>

Notes: Since the method get_pinn_number() is 'private', the only place you can use this method is in the same class - typically in another method. If you wanted to call/use this method directly in your PHP pages, you would need to declare it 'public'.

Nerd Note: Again, it is important (as we go along,) that you actually try the code yourself. It makes a HUGE difference!

Questions?

Just post them on the PHP forum.

Top of page  go to top of page