OOP and Exception Handling
in PHP
Khalilullah Akbari
+93 729908855
Khalil.akbari18@[Link]
PHP OOP
Definition
OOP stands for Object-Oriented Programming.
Procedural programming is about writing procedures or functions that perform
operations on the data, while object-oriented programming is about creating objects
that contain both data and functions.
Object-oriented programming has several advantages over procedural programming:
OOP is faster and easier to execute
OOP provides a clear structure for the programs
OOP makes it possible to create full reusable applications
Classes and Objects
Classes and objects are the two main aspects of object-oriented
programming.
Example:
There is a class of Car, and its objects are Volvo, Toyota, Audi, …
Define a Class
A class is defined by using the class keyword, followed by the name of the class and a
pair of curly braces ({}). All its properties and methods go inside the braces:
Syntax
<?php
class Fruit {
// code goes here...
}
?>
Example
<?php
class Fruit { // Making objects
// Properties
public $name; $apple = new Fruit();
public $color; $banana = new Fruit();
$apple->set_name('Apple');
// Methods $banana->set_name('Banana');
function set_name($name) {
$this->name = $name; echo $apple->get_name();
} echo "<br>";
function get_name() { echo $banana->get_name();
return $this->name;
} ?>
}
The $this Keyword
The $this keyword refers to the current object, and is only available inside methods.
<?php
Example: class Fruit {
public $name;
function set_name($nameofuser) {
$this->name = $nameofuser;
}
}
$apple = new Fruit();
$apple->set_name("Apple");
echo $apple->name;
?>
Constructor
<?php
class Fruit {
A constructor allows you to initialize an public $name;
object's properties upon creation of the public $color;
object.
function __construct($name) {
$this->name = $name;
If you create a __construct() function, PHP }
will automatically call this function when you function get_name() {
return $this->name;
create an object from a class. }
}
$apple = new Fruit("Apple");
echo $apple->get_name();
?>
Access Modifiers
Properties and methods can have access modifiers which control where they can be
accessed.
There are three access modifiers:
•public - the property or method can be accessed from everywhere. This is default.
•protected - the property or method can be accessed within the class and by
classes derived from that class.
•private - the property or method can ONLY be accessed within the class.
Access Modifiers
<?php
class Fruit {
public $name;
protected $color;
private $weight;
}
Inheritance
PHP inheritance in OOP = When a class derives from another class.
The child class will inherit all the public and protected properties and methods from
the parent class. In addition, it can have its own properties and methods.
An inherited class is defined by using the extends keyword.
Inheritance
<?php // Strawberry is inherited from Fruit
class Fruit { class Strawberry extends Fruit {
public $name; public function message() {
public $color; echo "Am I a fruit or a berry? ";
public function __construct($name, $color) }
{ }
$this->name = $name; $strawberry
$this->color = $color; = new Strawberry("Strawberry", "red");
} $strawberry->message();
public function intro() { $strawberry->intro();
echo "The fruit is {$this->name} and the ?>
color is {$this->color}.";
}
}
PHP Namespaces
Namespaces are qualifiers that solve two different problems:
❑ They allow for better organization by grouping classes that work together to
perform a task
❑ They allow the same name to be used for more than one class.
Declaring a Namespace
Namespaces are declared at the beginning of a file using the namespace keyword.
Syntax
Declare a namespace called Html:
namespace Html;
A namespace declaration must be the first thing in the PHP file
Declaring a Namespace
<?php
namespace Html; <!DOCTYPE html>
class Table { <html>
public $title = ""; <body>
public $numRows = 0;
public function message() { <?php
echo "<p>Table '{$this->title}' has {$this- $table->message();
>numRows} rows.</p>"; ?>
}
} </body>
$table = new Table(); </html>
$table->title = "My table";
$table->numRows = 5;
?>
Using Namespaces
Any code that follows a namespace declaration is operating inside the namespace, so
classes that belong to the namespace can be instantiated without any qualifiers.
$table = new Html\Table()
$row = new Html\Row();
PHP Exceptions
PHP Exceptions
An exception is an object that describes an error or unexpected
behavior of a PHP script.
Exceptions are thrown by many PHP functions and classes.
User defined functions and classes can also throw exceptions.
Exceptions are a good way to stop a function when it comes across
data that it cannot use.
Throwing an Exception
The throw statement allows a user
defined function or method to throw <?php
an exception. When an exception is function divide($dividend, $divisor) {
if($divisor == 0) {
thrown, the code following it will not throw new Exception("Division by zero");
be executed. }
return $dividend / $divisor;
}
echo divide(5, 0);
?>
The try...catch Statement
To avoid the error from the example above, we can use the try...catch statement to
catch exceptions and continue the process.
Syntax:
try {
//code that can throw exceptions
} catch(Exception $e) {
//code that runs when an exception is caught
}
Example
<?php
function divide($dividend, $divisor) {
if($divisor == 0) {
throw new Exception("Division by zero");
}
return $dividend / $divisor;
}
try {
echo divide(5, 0);
} catch(Exception $e) {
echo "Unable to divide.";
}
?>
Methods
Method Description
getMessage() Returns a string describing why the exception was thrown
getPrevious() If this exception was triggered by another one, this method returns the previous
exception. If not, then it returns null
getCode() Returns the exception code
getFile() Returns the full path of the file in which the exception was thrown
getLine() Returns the line number of the line of code which threw the exception
Example
try {
echo divide(5, 0);
} catch(Exception $ex) {
<?php
$code = $ex->getCode();
function divide($dividend, $divisor) {
$message = $ex->getMessage();
if($divisor == 0) {
$file = $ex->getFile();
throw new Exception("Division by
$line = $ex->getLine();
zero", 1);
echo "Exception thrown in $file on line
}
$line: [Code $code]
return $dividend / $divisor;
$message";
}
}
?>
Thank You
