Object Oriented PHP for Beginners: Steps 1 – 6

Programing Coderfunda October 27, 2018 object, oop's, php No comments

Object Oriented PHP for Beginners: Steps 1 – 7

Step 1:

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"); ?>  
<?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;
?>

Step 2:

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 3:

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"); ?>  
<?php 
 $stefan = new person("Stefan Mischook");
 echo "Stefan's full name: ".$stefan->get_name();
?>

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 fewer bugs.

Step 4:

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:

public
private
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 5:

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"); ?>
<?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;  
?>

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 6:

Restricting access to methods

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

public
protected
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!

Object Oriented PHP for Beginners: Steps 1 – 6

Programing Coderfunda October 27, 2018 object, oop's, php No comments

Object Oriented PHP for Beginners: Steps 1 – 7

Step 1:

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"); ?>  
<?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;
?>

Step 2:

Constructors

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 3:

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"); ?>  
<?php 
 $stefan = new person("Stefan Mischook");
 echo "Stefan's full name: ".$stefan->get_name();
?>

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 fewer bugs.

Step 4:

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:

public
private
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 5:

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"); ?>
<?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;  
?>

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 6:

Restricting access to methods

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

public
protected
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;  
  }       
 }   
?>

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

THE DIFFERENCE BETWEEN CLASSES AND OBJECTS IN PHP

Programing Coderfunda October 27, 2018 class, object, oop's, oops, php No comments

The standards for WordPress development are slowly moving from turns of procedural code that lack proper abstraction to more SOLID and object-oriented code.

That’s a step in the right direction, but let’s not forget two important things that often get left out of these discussions: putting code in a class does not make it “object-oriented,” and object-oriented PHP is not, by definition better.

Today, we will discuss what what an object is and what its role is. Then we can discuss what we mean by “true object-oriented programming” and whether it really matters if your code is “true OOP” or not.

Arrays vs Objects

PHP has two compounds (also known as composite) data types: objects and arrays. Compound data types require composition — the process of combining other data types into one “unit.” In purely object-oriented languages, we have to compose data types that in PHP are available to us as primitive types.

When explaining objects and object-oriented programming, I think it is really useful to start by talking about arrays, which are not objects. The fundamental difference between a PHP array and an object is that we can’t change the rules of an array. PHP the language defines what we can and can’t do with an array and there is no way for your PHP program to change that.

Objects on the other hand, have rules defined by the PHP program they are running in. These rules are what we call classes.

While every array plays by the same rule, each object plays by the rules of objects and by the rules of the class used to create them.

Instances

Sometimes the words “class” and “object” are used interchangeably, but they should not be. As I said above, classes are rules for creating objects, but those objects do not exist until they are instantiated.

Class instantiation happens using the new keyword. If I want an instance of the WP_Query class, I could create one like this:

PHP
1
$products = new WP_Query( [ 'post_type' => 'product' ] );

Instantiating a class and calling a function are very similar, but function calls are not preceded by the new keyword.

When a class is instantiated, its constructor is called immediately and any arguments injected into the class are passed to the constructor. Constructors are an example of a PHP magic method. They are a way to inject data directly into the object and also to run code immediately on instantiation.

As you noticed, I passed an array of arguments to the WP_Query class when I instantiated the object. If you look inside WP_Query’s constructor, if the one argument it accepts isn’t empty, that argument is passed to the query method of that class.

The query method sets off the process that WP_Query is used for — querying the database to get posts. Separating that method out from the constructor is good design as it keeps the constructor from taking on too many responsibilities. It also allows us to control when the query is run. While most of the time it is fine to run the query right away, the flexibility that separating query() from __construct() is very useful.

While WP_Query has lots of rules, they apply to all objects or WP_Query, that does not mean all objects of WP_Query are the same. That’s because their properties will contain different information. For example, look at this code:

1
2
3
$products = new WP_Query( [ 'post_type' => 'product' ] );
 
$orders = new WP_Query( [ 'post_type' => 'shop_order' );

We now have two instances of the WP_Query class. Each one will contain totally different posts in their posts property, but the way that those posts got there and the way that they can be accessed or changed is the same.

What An Object Is An Instance Of

In the last section, I talked about objects that were instances of WP_Query. What we mean is that these objects were created using the WP_Query class. But, let’s not forget that classes can be subclassed. When an object is an instance of a class that extends another class, then it is considered an instance of both classes.

This is an important distinction because it determines how the function is_a() will function as well as type hinting rules. If I make a class that extends WP_Query, it will be considered an instance of WP_Query. This is one of the features of object inheritance that makes it so useful.

Let’s say you had an abstract class called “social” and two classes that extended it called “Facebook” and “Twitter”. You could identify the instance of these classes by checking if they were instanced of “social.”

What Is $this?

Inside of a class, you can access the current instance using the special variable $this. Outside of a class you can not use $this or PHP will throw an error. Inside of a class, you use $this to access properties or methods of that class.

The variable $this always refers to the current object, no matter which class in the inheritance hierarchy you are. On the other hand the keyword “self” refers to the current class, not the current instance. Static properties are not unique to a specific object, they are unique to a class.

“True” Object-Oriented Programming

A lot of time we see classes that don’t really represent a discernible object. Instead, they are a collection of related functions. In this case, the class acts as a namespace. This may or may not be a bad thing.

We always should test these situations on a case by case basis. In my opinion, it comes down to whether the code could be rewritten as a collection of functions that were not contained in a class. I say this because writing a class, just to avoid using unique function prefixes is no excuse to use a class, and is less performant and less flexible.

If the only utility of a class is avoiding using unique prefixes, then why not just group the functions into a file and use a namespace in that file?

But, keep in mind that classes have inheritance, visibility, and properties, which a group of functions do not. These are perfectly good reasons to use a class, even when it is not “true” object-oriented PHP.

In these situations, you are often dealing with a class where one instance is indiscernible from the next. Instantiating these classes into objects and tracking those objects is almost always a bad code smell and unnecessary. In these situations, it is often better to declare all methods of the class static, so instantiation is unneeded.

Many people will tell you that just because you’re using a class doesn’t mean you are using object-oriented programming. They are right. Just don’t forget that object-oriented programming is not categorically better than the alternatives.

27 October, 2018

Object Oriented PHP for Beginners: Steps 1 – 6

Object Oriented PHP for Beginners: Steps 1 – 7

Step 1:

Step 2:

Step 3:

Step 4:

Step 5:

Step 6:

Object Oriented PHP for Beginners: Steps 1 – 6

Object Oriented PHP for Beginners: Steps 1 – 7

Step 1:

Step 2:

Step 3:

Step 4:

Step 5:

Step 6:

THE DIFFERENCE BETWEEN CLASSES AND OBJECTS IN PHP

Arrays vs Objects

Instances

What An Object Is An Instance Of

What Is $this?

“True” Object-Oriented Programming

Meta

Popular Posts

Categories

Social Media Links

Pages

Blog Archive

Laravel News