Lecture Notes On Class 21 Object-Oriented Programming (OOP) - Part 3

Lecture Notes On Class 21

Object-Oriented Programming (OOP) - Part 3

---

Objective:

1. Learn about constructors and destructors in PHP classes.
2. Understand object initialization and cleanup.

Outcome:

• Students will be able to implement constructors for object setup and destructors for cleanup tasks.

---

Overview of Class Topics

1. Recap of Object-Oriented Programming (OOP) Basics
2. Constructors in PHP
3. Destructors in PHP
4. Example Code for Constructors and Destructors
5. Practical Use Cases

---

1. Recap of Object-Oriented Programming (OOP) Basics

Before diving into constructors and destructors, let’s quickly review some key OOP concepts:

• Class: A blueprint for creating objects, containing properties (attributes) and methods (functions).
• Object: An instance of a class, created to perform actions or store data as per the class definition.
• Properties and Methods: Variables and functions defined within a class to hold data and perform actions, respectively.

In this class, we focus on two essential OOP methods: constructors and destructors.

---

2. Constructors in PHP

A constructor is a special function within a class that is automatically called when a new object of that class is created. It helps initialize object properties or perform any necessary setup tasks.

Key Points:

• In PHP, constructors are defined using the __construct() method.
• The __construct() method runs immediately when a new object is created.
• Constructors can accept parameters, allowing us to pass data directly to an object when it's created.

Syntax for Constructor

class ClassName {

    public function __construct(parameters) {

        // Initialization code here

    }

}

Example

class User {

    public $name;

 

    // Constructor

    public function __construct($name) {

        $this->name = $name;

        echo "User created: $this->name<br>";

    }

}

 

// Creating an object of the User class

$user1 = new User("Alice");

$user2 = new User("Bob");

In this example:

• The __construct($name) method accepts a $name parameter.
• When new User("Alice") is called, the __construct method is triggered, setting $this->name to "Alice" and printing a message.

Why Use Constructors?

• Initialization: Constructors are ideal for setting initial values for object properties.
• Simplified Code: Constructors streamline the setup process, reducing repetitive code when creating multiple instances.

---

3. Destructors in PHP

A destructor is a special function within a class that is called automatically when an object is no longer needed or when a script ends. Destructors are useful for cleanup tasks, such as closing database connections or freeing up resources.

Key Points:

• In PHP, destructors are defined using the __destruct() method.
• The __destruct() method is automatically called at the end of a script or when an object is destroyed.
• Destructors do not accept parameters, and only one destructor per class is allowed.

Syntax for Destructor

class ClassName {

    public function __destruct() {

        // Cleanup code here

    }

}

Example

class FileHandler {

    private $file;

 

    // Constructor to open a file

    public function __construct($filename) {

        $this->file = fopen($filename, "w");

        echo "File opened.<br>";

    }

 

    // Destructor to close the file

    public function __destruct() {

        fclose($this->file);

        echo "File closed.<br>";

    }

}

 

// Creating an object of the FileHandler class

$fileHandler = new FileHandler("example.txt");

// The file will be automatically closed when $fileHandler is no longer needed

In this example:

• The constructor __construct($filename) opens a file when the object is created.
• The destructor __destruct() closes the file when the object is destroyed.

Why Use Destructors?

• Resource Management: Destructors ensure resources like file handles or database connections are properly closed.
• Automatic Cleanup: Using destructors means cleanup tasks are handled automatically, reducing errors and improving code safety.

---

4. Example Code for Constructors and Destructors

To demonstrate the functionality of constructors and destructors together, let’s create a Database Connection class:

class DatabaseConnection {

    private $connection;

 

    // Constructor to initialize the connection

    public function __construct($host, $user, $password, $dbname) {

        $this->connection = mysqli_connect($host, $user, $password, $dbname);

        if ($this->connection) {

            echo "Connected to the database.<br>";

        } else {

            echo "Database connection failed: " . mysqli_connect_error();

        }

    }

 

    // Destructor to close the connection

    public function __destruct() {

        mysqli_close($this->connection);

        echo "Database connection closed.<br>";

    }

}

 

// Creating a DatabaseConnection object

$db = new DatabaseConnection("localhost", "root", "password", "my_database");

Explanation

• Constructor (__construct): When a DatabaseConnection object is created, it connects to the specified database.
• Destructor (__destruct): When the object is no longer needed, the destructor closes the database connection.

This example demonstrates how constructors and destructors can automate setup and cleanup in real-world applications.

---

5. Practical Use Cases

1. User Authentication Systems:
• The constructor can accept user credentials, initialize user sessions, and check login status.
• The destructor can log users out or clear session data.
2. File Processing:
• Use a constructor to open a file for reading or writing and a destructor to close it.
3. Database Interactions:
• A constructor connects to a database and a destructor closes the connection when operations are complete.
4. Session Management:
• Constructors can initialize sessions, while destructors clean up or log session activity.

---

Summary

• Constructors (__construct) help initialize object properties or perform setup tasks when an object is created.
• Destructors (__destruct) handle cleanup tasks, like releasing resources, when an object is no longer needed.
• Proper use of constructors and destructors enhances code structure, efficiency, and resource management, making your PHP applications more reliable and easier to maintain.

---

Practice Exercise

1. Create a Class for a Student:
• Use a constructor to initialize a student’s name, ID, and enrolled course.
• Use a destructor to print a message when the student object is no longer needed.
2. Create a File Handling Class:
• The constructor should open a specified file, and the destructor should close it.

Solutions

Here’s a solution to create a class for a Student in PHP that includes a constructor to initialize the student’s name, ID, and enrolled course, along with a destructor to print a message when the student object is no longer needed.

PHP Code Implementation

<?php  class Student {     // Properties to hold student details     private $name;     private $id;     private $course;       // Constructor to initialize student details     public function __construct($name, $id, $course) {         $this->name = $name;         $this->id = $id;         $this->course = $course;         echo "Student object created: {$this->name}, ID: {$this->id}, Course: {$this->course}\n";     }       // Destructor to clean up     public function __destruct() {         echo "Student object '{$this->name}' with ID '{$this->id}' is no longer needed.\n";     }       // Method to display student details     public function displayInfo() {         echo "Name: {$this->name}, ID: {$this->id}, Course: {$this->course}\n";     } }   // Example usage $student1 = new Student("Alice Johnson", 101, "Computer Science"); $student1->displayInfo(); // Display student info   // When the script ends or the object goes out of scope, the destructor is called automatically ?>

 

Explanation

1.   Class Definition:

o    We define a class named Student.

o    Inside the class, we declare three private properties: $name, $id, and $course to store the student's details.

2.   Constructor:

o    The constructor __construct is a special method that is called when a new object of the class is created.

o    It takes three parameters: $name, $id, and $course.

o    The constructor initializes the properties with the provided values and prints a message indicating that the student object has been created. This helps in verifying that the constructor is functioning correctly.

3.   Destructor:

o    The destructor __destruct is another special method that is called when an object is destroyed or goes out of scope.

o    It prints a message indicating that the student object is no longer needed, which is useful for cleanup or debugging.

4.   Method to Display Student Information:

o    We have an additional method displayInfo() to output the student's details. This method can be called anytime to display the current state of the object.

5.   Example Usage:

o    We create a new instance of the Student class, named $student1, and initialize it with the student's name, ID, and course.

o    We then call the displayInfo() method to print the student's details.

o    When the script ends, or the object $student1 goes out of scope, the destructor is automatically called, displaying the message defined in it.

Output

When this code is executed, the output will look like this:

Student object created: Alice Johnson, ID: 101, Course: Computer Science

Name: Alice Johnson, ID: 101, Course: Computer Science

Student object 'Alice Johnson' with ID '101' is no longer needed.

2. PHP Code Implementation

<?php  class FileHandler {     // Property to hold the file handle     private $fileHandle;       // Constructor to open the specified file     public function __construct($fileName, $mode = 'r') {         // Attempt to open the file and handle any errors         $this->fileHandle = fopen($fileName, $mode);                 if (!$this->fileHandle) {             throw new Exception("Unable to open file: $fileName");         }         echo "File '$fileName' opened successfully.\n";     }       // Method to read contents of the file     public function readFile() {         if ($this->fileHandle) {             // Read the entire file content             $content = fread($this->fileHandle, filesize($this->fileHandle));             return $content;         } else {             throw new Exception("File is not open for reading.");         }     }       // Destructor to close the file handle     public function __destruct() {         if ($this->fileHandle) {             fclose($this->fileHandle);             echo "File handle closed.\n";         }     } }   // Example usage try {     // Create a new FileHandler object for a specified file     $fileHandler = new FileHandler("example.txt", "r");         // Read the content of the file     $content = $fileHandler->readFile();     echo "File Content:\n$content";   } catch (Exception $e) {     // Handle any exceptions that are thrown     echo "Error: " . $e->getMessage() . "\n"; }   // When the script ends, the destructor is called automatically ?>

 Explanation

1.   Class Definition:

o    We define a class named FileHandler.

o    Inside the class, we declare a private property $fileHandle to store the file handle once the file is opened.

2.   Constructor:

o    The constructor __construct takes two parameters: $fileName (the name of the file to open) and an optional $mode (the mode in which to open the file, defaulting to 'r' for read).

o    Inside the constructor, the fopen function attempts to open the specified file. If the file cannot be opened, an exception is thrown, which is caught in the example usage.

o    A success message is printed if the file opens correctly.

3.   Method to Read File Contents:

o    The readFile() method checks if the file handle is open and then reads the entire content of the file using fread().

o    The method returns the content of the file. If the file is not open, an exception is thrown to inform the user.

4.   Destructor:

o    The destructor __destruct checks if the file handle is still open when the object is destroyed.

o    If it is, the fclose() function is called to close the file handle, and a message is printed to confirm closure. This ensures that resources are properly released.

5.   Example Usage:

o    We create an instance of the FileHandler class and pass the filename ("example.txt") and mode ("r") as arguments.

o    We call the readFile() method to read the content of the file and print it.

o    The try-catch block handles any exceptions that might occur during file opening or reading, providing a way to deal with errors gracefully.

Output

When this code is executed, the output will look something like this (assuming the file example.txt exists):

File 'example.txt' opened successfully.

File Content:

[Content of example.txt]

File handle closed.

This implementation demonstrates how to manage file handling using constructors and destructors in PHP, ensuring proper resource management while performing file operations.