All magic methods names start with two underscores. To implement constructor and destructor we have to override __construct() and __destruct() methods. The method __construct is invoked when we create an object and __destruct when all references on an object are removed or an object is explicitly destroyed.

class MilitaryBaracks {
 
  // note that construct methods starts with two underscores
  public function __construct() {
    // this code executes when object is created
    echo "Soldier " . $this->name . " was created.";
  }

  // ... rest of the class code
  
  public function __destruct() {
    // this code executes when object is destroyed
    echo "Destroying solider with name " . $this->name;
  }
}

We use constructor in cases, when we want to execute some piece of code when object is instantiated. For instance, set values to properties for which we want to be sure they are set. In case of a class which takes care of connecting to database, we would want to be sure that we have all data required for establishing connection. We could use destructor to close the connection. In practice, constructor is much more often used than destructor because PHP closes resources it uses when script finishes execution. Anyway, this stackoverflow link offers few examples of uses of destruct method in open source code.

For the sake of clarity, let’s build upon our MilitaryBaracks example. We want to be sure that every soldier has name and weapon.

class MilitaryBaracks {
 
  // name doesn't have default value no more
  private $_name;
  // so doesn't weapon
  private $_weapon;
 
  private $_ammunition = 10;
 
  // instead, we make sure that values are passed when object is created
  public function __construct($name, $weapon) {
    $this->_name = $name;
    $this->_weapon = $orozje;
  }

  // we want that soldier is able to switch weapon
  // so we create getter method to access weapon variable value
  public function getWeapon() {
    return $this->_weapon;
  }
 
  // and set method to switch weapon
  public function setWeapon($weapon) {
    $this->_weapon = $weapon;
    return $this;
  }
 
  // name can't be changed, so we create only getter method
  public function getName() {
    return $this->_name;
  }
 
  //...
}

Ookay, let’s print out a few lines:

// this is wrong because of missing arguments
$soldier = new MilitaryBaracks();
// the right way
$soldier = new MilitaryBaracks('Mougli', 'rifle');
 
echo $soldier->getname() . " has weapon " . $soldier->getWeapon() . ".<br>";
 
$soldier->setWeapon('gun');

echo $soldier->getName() . " has weapon " . $soldier->getWeapon() . "."; 

And we get:

This way our object are easier to instantiate and set, since we do everything in one line. Beside that, now we can be pretty sure that our objects have all needed properties set, as PHP throws a warning if we leave out an argument when instantiating new object. Our code and classes needs to be organized in a way that other programmers can easily understand its meaning and structure. The predictability is important “guide” of OOP.

Even though I previously announced a blog post about inheritance I saved it for next time. I intended to present constructor and inheritance in this post, but it would be too long and I want to keep series short and simple. For that reason I cover it in the next post.

The methods differ from the functions in that they are declared in the class.

public function myMethod() {
 
}

They support different types of visibility just like properties do. Visibility keywords are: public, protected and private. These keywords define from where we can access the method. Public methods can be accessed from anywhere while private methods can only be accessed in the same class they are defined in. There is also protected keyword, but we will take a closer look at it a bit later. First, let’s just take a look at the example of using public and private keywords.

class MilitaryBaracks {
 
  //properties that we can access anywhere
  public $name = 'Mougli';
  public $weapon = 'rifle';
 
  //properties that we can access in this class only
  //in practice we usually prepend _ to the private methods for the clarity
  private $_ammunition = 10;
 
  //because we are inside the class, which defines property $_ammunition, we can access that property
  public function getAmmunition() {
    return $this->_ammunition;
  }
 
  public function shoot() {
    //keyword this means that we refer to property of an instance of class -> an object
    //if soldier has any ammunition left, shoot and subtract one bullet
    if($this->_ammunition > 0) {
      $this->_ammunition = $this->_ammunition - 1;
       
      return true;
    }
    return false;
  }
}

Let’s take a look at the above code in more detail. I’ve added a private property $_ammunition and methods getAmmunition() and shoot(). Because we cannot access a private property, we need to create a public method, which returns its value (getAmmunition()). Method shoot() reduces a number of bullets left each time it is called.

It is a common practice to prepend _ to the private properties. This helps to quickly differentiate private properties from public. Maybe all this is confusing, so let me clear it up a bit with an example. Let’s see what happens if I try to change and print out both properties.

// we instantiate an object of type MilitaryBaracks
$soldier = new MilitaryBaracks();
 
// and print out its name (its property)
echo $soldier->name;
echo "<br>";
// we change its name to "Matic"
$soldier->name = 'Matic';
echo $soldier->name;
echo "<br>";
echo $soldier->_ammunition;

This is what we get:

As you see we can access and modify public properties values just like variables, but we cannot do that with private ones. This is a mechanism to protect properties which values shouldn’t be changed from outside the class. But sometimes (actually quite often) we want to access the private properties from outside of class scope. In that case we create a public method like we did in our case. That way we can enforce the rules – what someone can do with that property. In our case we want to allow just reading so we created a getAmmunition() method.

$soldier = new MilitaryBaracks();
echo "Soldier has " . $soldier->getAmmunition() . " bullets.";
echo "Soldier shoots.";
$soldier->shoot();
echo "Soldier has " . $soldier->getAmmunition() . " bullets.";

What does keyword $this means? With the use of $this keyword a class knows it’s operating on this object. For simplicity try changing word $this with “current object instance”.

When I was learning about OOP I was asking myself why would I set a method or property to private, if that just makes things more complicated. You have to write more code, because you have to write an additional method to access the property. Here is the answer. The thing with OOP is that we want to limit the access to class properties and methods as much as possible. This way me try to make code more clear and harder to use in a wrong way.

That is not so obvious in my case, because the example is to simple. But I hope it will become more clear in an upcoming posts, where we will roll up our sleeves and get to some more serious programming .

In next post of this series we will cover one of the most important but also more complex topic of object oriented programming, that is inheritance.

In the first part of this series I will try to lay out the most basic terms as simple as possible. I will describe what is an object, class and a property.

Class

Personally I see a class as some kind of a frame, with which help we generate objects. I would say that the best comparison is the one with a computer game e.g. old strategic game – Age Of Empires. Each building, that we create has a special task. Let’s say it generates soldiers. So, we create a class MilitaryBarack (a building in the game) and that class generates objects (soldiers in the game).

We create a class with a reserved word class ClassName and brackets {}.

class MilitaryBarack 
{
}

Even though this piece of code is perfectly legit, it is pretty useless, because it doesn’t do anything. We will fix that later.

Object

As I mentioned before, class generates, or more accurately, instantiates an object. But what is an object? Let me return back to game comparison. MilitaryBracket generates an object, a soldier, which has certain properties. In programming terms we say that an object is an instance of a class. We instantiate it with the use of a reserved word new plus the ClassName.

$soldier1 = new MilitaryBaracks();
$soldier2 = new MilitaryBaracks();

When we create new instance of an object, it gets a unique identity. We can print object id and all of its properties with very useful function var_dump();.

var_dump($soldier1);
var_dump($soldier2);

If we open that in browser, we will see the output

object(MilitaryBaracks)[1] // note the object id in square brackets. Object has no properties yet.

object(MilitaryBaracks)[2]

Properties

All of this code is still quite useless. To make it more useful, we will add it some properties. Property of an object can contain different types of data. In our case, we could use a soldier’s name and a type of weapon he carries. To assign properties to an object, we have to declare it in its class. PHP offers three types of properties: public, protected and private. I will write more about the meaning of this words in next posts. For now it is enough to know, that they exist. We declare property with one of these reserved words plus a variable.

// class
class MilitaryBaracks {
  // and its properties with defined default values
  public $name = 'Mougli';  
  public $weapon = 'rifle';
}

As you se, we defined two properties to MilitaryBaracks class. If we now instantiate and print a new object, we can see all values it holds. To access the property value we use an arrow (->).

$soldier = new MilitaryBaracks();
echo "Soldier " . $soldier->name . " carries a " . $soldier->weapon;

These is were I stop for today. In part 2 of these series I will write about methods and visibility.