PHP OOPs

Constructors are special methods used for initial settings when new instances of a class are created. They play a key role in PHP’s object-oriented programming model introduced in PHP5. Constructors act as the blueprint for creating objects, initializing their properties, and defining their behavior. Once the object is initialized, the constructor is automatically called. In contrast, destructors handle object cleanup and are automatically invoked at the end of the script execution.

In this article, we’ll explore constructors and destructors, two important concepts in PHP’s object-oriented programming.

Both constructors and destructors are special member functions, with the primary difference being that destructors are preceded by a ~ (tilde) symbol.

Constructor Syntax:

__construct():

function __construct()
{
   // Initialize the object and its properties
}

Destructor Syntax:

__destruct():

function __destruct()
{
   // Cleanup code
}

Note: The constructor is defined in the public section of the class. It is responsible for setting the initial values of the class properties.

Types of Constructors:

1. Default Constructor: It has no parameters but can accept dynamic values during object creation.
2. Parameterized Constructor: This constructor accepts parameters and assigns them to class properties.
3. Copy Constructor: This accepts another object as an argument and initializes the new object from it.

Inheritance and Constructors:

Constructors are inherited by child classes. If a child class defines its own constructor, it will be called instead of the parent’s constructor.

Pre-defined vs. User-defined Constructor:

When a class contains both the pre-defined __construct() and a user-defined constructor, __construct() will act as the constructor while the user-defined one behaves like a regular method.

Example 1: Pre-defined Constructor in PHP Class

<?php
class Plant
{
    function Plant()
    {
        echo "This is a user-defined constructor for the Plant class.";
    }

    function __construct()
    {
        echo "This is the pre-defined constructor for the Plant class.";
    }
}

$obj = new Plant();
?>

Output:

This is the pre-defined constructor for the Plant class.

Example 2: Parameterized Constructor

In this example, the constructor takes parameters and sets the object’s properties accordingly.

<?php

class Vehicle
{
    public $make;
    public $model;

    function __construct($make, $model)
    {
        $this->make = $make;
        $this->model = $model;
    }

    function show_details()
    {
        echo "Make: " . $this->make . ", Model: " . $this->model . "\n";
    }
}

$vehicle1 = new Vehicle("Toyota", "Corolla");
$vehicle1->show_details();

$vehicle2 = new Vehicle("Honda", "Civic");
$vehicle2->show_details();

?>

Output:

Make: Toyota, Model: Corolla
Make: Honda, Model: Civic

Inheritance and Constructors

If a child class has its own constructor, both the child’s and parent’s constructors will be called in order.

Example 3: Constructor in Parent and Child Classes

<?php
class Animal
{
    function __construct()
    {
        print "Animal class constructor.\n";
    }
}

class Dog extends Animal
{
    function __construct()
    {
        parent::__construct(); // Call the parent constructor
        print "Dog class constructor.\n";
    }
}

$obj1 = new Animal();
$obj2 = new Dog();
?>

Output:

Animal class constructor.
Animal class constructor.
Dog class constructor.

Destructor in PHP

Destructors are used to clean up resources when an object is no longer needed. They are automatically called when the object goes out of scope or the script ends.

Example 4: Destructor

<?php
class Item
{
    function __construct()
    {
        echo "In constructor, ";
        $this->name = "Item Object";
    }

    function __destruct()
    {
        echo "destroying " . $this->name . "\n";
    }
}

$obj = new Item();
?>

Output:

In constructor, destroying Item Object

Note: In cases of inheritance, if both the parent and child class have destructors, the destructor of the child class is executed first, followed by the parent’s destructor.

Advantages of Constructors:

1. Automatic Initialization: Constructors allow automatic initialization of object properties when creating an instance.
2. Flexibility with Parameters: They can take multiple parameters, enabling dynamic initialization.
3. Reusability: Objects can be reused without having to reinitialize their properties each time.
4. Session Management: Constructors can initiate sessions, removing the need to start them manually in every function.

Destructor:

Destructors clean up resources and free memory before an object is destroyed. They are especially useful for closing file handles or database connections.

Constructor vs. Destructor Comparison

Example 5: Destructor in Inherited Class

<?php
class ParentClass
{
    function __destruct()
    {
        echo "Destructor of Parent Class\n";
    }
}

class ChildClass extends ParentClass
{
    function __destruct()
    {
        echo "Destructor of Child Class\n";
        parent::__destruct(); // Call parent destructor
    }
}

$obj = new ChildClass();
?>

Output:

Destructor of Child Class
Destructor of Parent Class

Constants in PHP are identifiers or names assigned to fixed values that remain unchanged throughout the program execution. Once a constant is set, it cannot be redefined or removed.

By convention, constant names are written in uppercase. By default, constants are case-sensitive and must start with a letter or an underscore, followed by letters, numbers, or underscores. Special characters, except for the underscore, are not allowed.

1. Creating a Constant Using define() Function: The define() function is commonly used to create constants in PHP.

Syntax:

define('CONSTANT_NAME', value, case_insensitive);

• name: The name of the constant.
• value: The value assigned to the constant.
• case_insensitive: Defines whether the constant should be case-insensitive. The default value is false, meaning the constant is case-sensitive.

Example: Creating Constants Using define() Function

<?php

// Creates a case-sensitive constant
define("GREETING", "Hello World");
echo GREETING . "\n";

// Creates a case-insensitive constant
define("WELCOME", "Hello Universe", true);
echo welcome;

?>

Output:

Hello World
Hello Universe

2. Creating a Constant Using const Keyword: The const keyword is another way to define constants, usually used within classes or functions. Unlike define(), constants defined using const are always case-sensitive.

Syntax:

const CONSTANT_NAME = value;

Example: Creating Constants Using const Keyword

<?php
const WEBSITE = 'MyWebsite';
echo WEBSITE;
?>

Output:

MyWebsite

3. Constants are Global: Constant global, meaning they can be accessed from any part of the script, including functions.

Example: Global Scope of Constants

<?php

define("MESSAGE", "PHP is Fun!");

function displayMessage() {
    echo MESSAGE;
}

echo MESSAGE . "\n";
displayMessage();

?>

Output:

PHP is Fun!
PHP is Fun!

In the example above, the constant MESSAGE can be accessed both inside and outside the function displayMessage() because constants have a global scope.

Difference Between Constants and Variables

Here are some key differences between constants and variables:

This updated content keeps the same meaning and structure but has revised wording and updated examples. The examples now reflect the typical usage of constants in PHP, and their respective outputs have been adjusted accordingly.

Interface in PHP allows developers to define the structure of the methods that a class must implement without specifying the exact implementation. It serves as a way to enforce a contract for classes and provides a higher level of abstraction. Interfaces are similar to abstract classes but do not include any method bodies or data members. They ensure that any class implementing the interface must include the methods described.

Defining an Interface

To define an interface, we use the interface keyword, similar to how we define a class, but without providing method implementations.

Syntax Example:

<?php

interface ExampleInterface {
   public function methodOne();
   public function methodTwo();
}

?>

Key Features of Interfaces:

1. Abstract Methods: All methods in an interface are abstract, meaning they contain no method bodies.
2. Visibility Scope: Methods defined in interfaces must be public.
3. Multiple Implementations: A class can implement multiple interfaces, unlike inheritance where a class can only extend one parent class.

Implementing an Interface

To implement an interface in a class, use the implements keyword. The class that implements the interface must provide implementations for all methods defined in the interface.

Example:

<?php

interface SimpleInterface {
   public function methodOne();
   public function methodTwo();
}

class MyClass implements SimpleInterface {
   public function methodOne() {
     echo "Method One executed.\n";
   }
   public function methodTwo() {
     echo "Method Two executed.\n";
   }
}

$obj = new MyClass;
$obj->methodOne();
$obj->methodTwo();

?>

Output:

Method One executed.
Method Two executed.

Concrete Class:

A class that implements an interface is called a Concrete Class. It must provide implementations for all the methods defined by the interface. If two interfaces have the same method name, ambiguity may occur and cannot be implemented in the same class. An interface can extend another interface using the extends keyword, just like class inheritance.

Interface Inheritance Example:

<?php

interface FirstInterface {
    public function functionOne();
}

interface SecondInterface extends FirstInterface {
    public function functionTwo();
}

class MyClass implements SecondInterface {
    public function functionOne() {
        echo "Function One from First Interface\n";
    }
    public function functionTwo() {
        echo "Function Two from Second Interface\n";
    }
}

$obj = new MyClass;
$obj->functionOne();
$obj->functionTwo();

?>

Output:

Function One from First Interface
Function Two from Second Interface

Practical Example of Interface Implementation:

<?php

interface BasicInterface {
    public function showMethod1();
    public function showMethod2();
}

class DemoClass implements BasicInterface {
    public function showMethod1() {
        echo "showMethod1 called.\n";
    }
    public function showMethod2() {
        echo "showMethod2 called.\n";
    }
}

$instance = new DemoClass;
$instance->showMethod1();
$instance->showMethod2();

?>

Output:

showMethod1 called.
showMethod2 called.

Benefits of Using PHP Interfaces

• Unrelated Classes Can Share Methods:
  Interfaces allow unrelated classes to implement the same set of methods, regardless of their inheritance hierarchy.
• Supports Multiple Inheritance:
  A class can implement multiple interfaces, enabling a form of multiple inheritance, unlike classes that can only extend a single parent class.
• Focus on Interface, Not Implementation:
  Interfaces allow the developer to focus on the interaction with an object rather than worrying about the actual implementation, maintaining consistency for the user of the interface.

Similar to C++, PHP namespaces provide a way to organize code and prevent name conflicts when reusing the same class, function, or constant names. Namespaces offer an abstract structure that lets you reuse names without encountering fatal errors due to naming conflicts.

Key points about namespaces in PHP:

• They serve as containers for your PHP code, allowing code reuse and preventing conflicts.
• Namespaces can include classes (including abstracts and traits), interfaces, functions, and constants.
• The namespace keyword is used to define a namespace.
• It must be declared at the top of a file before any other code (except the declare keyword).
• A namespace can hold valid PHP code, just like a regular PHP script.

Example: Declaring a Namespace

<?php
namespace MyNamespace {

    // This is regular PHP code
    function hello()
    {
        echo 'Hello, I am running from a namespace!';
    }
}
?>

Global Namespace Declaration

If the namespace is to be declared globally (i.e., without a specific name), it is done like this:

<?php
namespace {
    // Code in the global space
}
?>

Declaring Multiple Namespaces in a Single File

You can declare multiple namespaces within a single PHP file:

<?php
namespace MyNamespace1 {
    // Code for the first namespace
}

namespace MyNamespace2 {
    // Code for the second namespace
}

namespace {
    // Code in the global namespace
}
?>

Namespaces are used to avoid conflicts and add flexibility and structure to your codebase. Just like directories in file systems, namespaces can be hierarchical. In PHP, the backslash (\) serves as the namespace separator.

Example: Using a Namespace

<?php
namespace MyNamespace;

function hello()
{
    echo 'Hello, I am running from a namespace!';
}

// This calls the function within the MyNamespace namespace
hello();

// Explicitly resolves to MyNamespace\hello
namespace\hello();
?>

Output:

Hello, I am running from a namespace!
Hello, I am running from a namespace!

Aliasing in Namespaces

Namespaces allow the use of aliases for ease of reference. The use keyword imports namespaces, and you can use the as keyword to create a custom alias.

Example: Aliasing in Namespaces

<?php
namespace MyNamespace;

require 'project/database/connection.php';

// Creating an alias for Project\Database\Connection
use Project\Database\Connection as Conn;

$connection = new Conn();

// Importing the Project\Database namespace with alias
use Project\Database as DB;

$connection = new DB\Connection();
?>

Dynamic Namespaces

Although you can dynamically include files in PHP, dynamic namespace importing is not supported.

Example: Dynamic Namespace Usage

<?php
namespace OtherProject;

$title = 'geeks';

// This is valid PHP code
require 'project/blog/title/' . $title . '.php';

// This will cause an error (invalid dynamic namespace)
use Project\Blog\title\$title;
?>

Runtime Error:

PHP Fatal error: Invalid namespace usage