PHP OOP - Classes and Objects

Welcome, apprentice, to the mystical realm of Object-Oriented Programming (OOP) in PHP. Here, we wield powerful spells known as Classes and harness magical beings called Objects. It's a different kind of enchantment, where code becomes a living, breathing entity. Are you ready? Let's unravel the mysteries of OOP in PHP!

What is OOP?

OOP is a programming paradigm where we write code as interacting entities, like characters in a magical tale. These entities are called objects, and they're molded from blueprints called classes. The spells they cast and the traits they possess, all are defined in the class.

OOP is a powerful tool that helps us write code that's easier to maintain and reuse. It's a different way of thinking about code, and it's a must-have skill for any PHP developer.

To understand OOP, we need to understand the following concepts:

• Classes and Objects
• Properties and Methods
• Constructors and Destructors
• Inheritance
• Polymorphism
• Encapsulation
• Abstraction

Let's dive in!

Classes and Objects

Creating a class is like crafting a magical artifact. It sets the stage for objects to come alive.

class Wizard {
  // properties and methods go here
}

An object is like a character in our magical tale, born from a class.

To create an object, we use the new keyword. It's like a magical incantation that brings the object to life.

$merlin = new Wizard();

Now, Merlin is an object of the Wizard class. Congratulations, you just brought a wizard to life!

Properties and Methods

Properties are like the traits of our objects - their name, age, or magical abilities. They're defined inside the class.

class Wizard {
  public $name = "Merlin";
  public $magicType = "Elemental";
}

Methods are like the spells our objects can cast. They're also defined inside the class.

class Wizard {
  public $name = "Merlin";
  public $magicType = "Elemental";

  public function castSpell() {
    echo "Fireball!";
  }
}

To access a property or method, we use the -> operator.

$merlin = new Wizard();
echo $merlin->name; // Merlin
$merlin->castSpell(); // Fireball!

Constructors and Destructors

A constructor is a special method that's invoked when an object is created. It's like the birth-cry of an object.

class Wizard {
  public $name;
  public $magicType;

  public function __construct($name, $magicType) {
    $this->name = $name;
    $this->magicType = $magicType;
  }
}

To create an object with a constructor, we pass the arguments to the new keyword.

$merlin = new Wizard("Merlin", "Elemental");

A destructor is a special method that's invoked when an object is destroyed. It's like the death-cry of an object.

class Wizard {
  public $name;
  public $magicType;

  public function __construct($name, $magicType) {
    $this->name = $name;
    $this->magicType = $magicType;
  }

  public function __destruct() {
    echo "The wizard {$this->name} has died.";
  }
}

To destroy an object, we use the unset() function.

$merlin = new Wizard("Merlin", "Elemental");
unset($merlin); // The wizard Merlin has died.

Inheritance

Inheritance is when a class derives properties and methods from another class. It's like a magical lineage. The class that's inherited from is called the parent class, and the class that inherits is called the child class.

class Wizard {
  public $name;
  public $magicType;

  public function __construct($name, $magicType) {
    $this->name = $name;
    $this->magicType = $magicType;
  }

  public function castSpell() {
    echo "Fireball!";
  }
}

class Necromancer extends Wizard {
  public function castSpell() {
    echo "Raise the dead!";
  }
}

To create an object of a child class, we use the new keyword.

$merlin = new Wizard("Merlin", "Elemental");
$undead = new Necromancer("Undead", "Necromancy");

To access a property or method of the parent class, we use the parent keyword.

class Necromancer extends Wizard {
  public function castSpell() {
    parent::castSpell();
    echo "Raise the dead!";
  }
}

Polymorphism

Polymorphism is when a method in a child class overrides the method in its parent class. It's like a magic trick with a twist. The method in the child class is called the overridden method, and the method in the parent class is called the overriding method.

class Wizard {
  public $name;
  public $magicType;

  public function __construct($name, $magicType) {
    $this->name = $name;
    $this->magicType = $magicType;
  }

  public function castSpell() {
    echo "Fireball!";
  }
}

class Necromancer extends Wizard {
  public function castSpell() {
    echo "Raise the dead!";
  }
}

To override a method, we define a method with the same name in the child class.

$merlin = new Wizard("Merlin", "Elemental");
$undead = new Necromancer("Undead", "Necromancy");

$merlin->castSpell(); // Fireball!
$undead->castSpell(); // Raise the dead!

Encapsulation

Encapsulation is the practice of hiding properties and methods from outside interference. It's like a magical shield. We can hide properties and methods by making them private.

class Wizard {
  private $name;
  private $magicType;

  public function __construct($name, $magicType) {
    $this->name = $name;
    $this->magicType = $magicType;
  }

  public function castSpell() {
    echo "Fireball!";
  }
}

To access a private property or method, we use a public method. It's like a magical key that unlocks the shield.

class Wizard {
  private $name;
  private $magicType;

  public function __construct($name, $magicType) {
    $this->name = $name;
    $this->magicType = $magicType;
  }

  public function getName() {
    return $this->name;
  }

  public function getMagicType() {
    return $this->magicType;
  }

  public function castSpell() {
    echo "Fireball!";
  }
}

Abstraction

Abstraction is when a class provides a generalized form to be inherited, but cannot be instantiated itself. It's like a mythical blueprint. We can make a class abstract by using the abstract keyword.

abstract class Wizard {
  public $name;
  public $magicType;

  public function __construct($name, $magicType) {
    $this->name = $name;
    $this->magicType = $magicType;
  }

  abstract public function castSpell();
}

To create an object of an abstract class, we use a child class.

class Necromancer extends Wizard {
  public function castSpell() {
    echo "Raise the dead!";
  }
}

Interfaces

An interface is a contract that a class must follow. It's like a magical oath. We can make a class follow an interface by using the implements keyword.

interface Wizard {
  public function castSpell();
}

class Necromancer implements Wizard {
  public function castSpell() {
    echo "Raise the dead!";
  }
}

To create an object of a class that follows an interface, we use the new keyword.

$undead = new Necromancer();

Interfaces are useful because they allow us to create objects of different classes that follow the same interface. It's like a magical army.

interface Wizard {
  public function castSpell();
}

class Necromancer implements Wizard {
  public function castSpell() {
    echo "Raise the dead!";
  }
}

class Sorcerer implements Wizard {
  public function castSpell() {
    echo "Lightning bolt!";
  }
}

$undead = new Necromancer();
$merlin = new Sorcerer();

Traits

A trait is a collection of properties and methods that can be used in multiple classes. It's like a magical spellbook. We can make a trait by using the trait keyword.

trait Wizard {
  public $name;
  public $magicType;

  public function __construct($name, $magicType) {
    $this->name = $name;
    $this->magicType = $magicType;
  }

  public function castSpell() {
    echo "Fireball!";
  }
}

Traits are useful because they allow us to reuse code in multiple classes. It's like a magical shortcut.

trait Wizard {
  public $name;
  public $magicType;

  public function __construct($name, $magicType) {
    $this->name = $name;
    $this->magicType = $magicType;
  }

  public function castSpell() {
    echo "Fireball!";
  }
}

class Necromancer {
  use Wizard;

  public function castSpell() {
    echo "Raise the dead!";
  }
}

class Sorcerer {
  use Wizard;

  public function castSpell() {
    echo "Lightning bolt!";
  }
}

$undead = new Necromancer("Undead", "Necromancy");
$merlin = new Sorcerer("Merlin", "Elemental");

$undead->castSpell(); // Raise the dead!
$merlin->castSpell(); // Lightning bolt!

With that, you've taken your first step into the realm of PHP OOP. It's a journey of a thousand spells, but remember, every great wizard started as an apprentice. Practice these concepts and soon you'll be crafting your own magical PHP tales.

As always, thanks for reading and happy coding!