This document provides an overview of object-oriented programming fundamentals in PHP, including classes, objects, inheritance, methods, properties, constructors, destructors, visibility, constants, interfaces, abstract classes, and exceptions. Key concepts covered are class declaration, object instantiation, class inheritance that allows extending and overriding methods and properties, defining and calling methods and properties, constructors and destructors, visibility levels for properties and methods, declaring and accessing properties, static methods and properties, class constants, interfaces for specifying APIs, abstract classes for defining basic skeletons, and exceptions for error control.

2. FUNDAMENTALS
•Classes
•Encapsulation
•Objects

3. CLASS DECLARATION
The basic declaration of a class is very simple:
class myClass {
// Class contents go here
}

4. OBJECT INSTANTIATION
This is done by using the new construct:
$myClassInstance = new myClass();
An object is always passed by reference rather than by value.
$myClassInstance = new myClass();
$copyInstance = $myClassInstance();

5. CLASS INHERITANCE
Allows a class to extend another class, essentially adding new methods and properties, as well as
overriding existing ones as needed.
class a {
function test()
{
echo "a::test called";
}
function func()
{
echo "a::func called";
}
}
class b extends a {
function test()
{
echo "b::test called";
}
}
class c extends b {
function test()
{
parent::test();
}
}
class d extends c {
function test()
{
b::test();
}
}
$a = new a();
$b = new b();
$c = new c();
$d = new d();

6. METHODS AND PROPERTIES
Methods are declared just like traditional functions:
class myClass {
function myFunction() {
echo "You called myClass::myFunction";
}
}
From outside the scope of a class, its methods are called using the indirection operator ->:
$obj = new myClass();
$obj->myFunction();

7. METHODS AND PROPERTIES
class myClass {
function myFunction($data) {
echo "The value is $data";
}
function callMyFunction($data) {
// Call myFunction()
$this->myFunction($data);
}
}
$obj = new myClass();
$obj->callMyFunction(123);

8. CONSTRUCTORS
class foo {
function __construct()
{
echo __METHOD__;
}
function foo()
{
// PHP 4 style constructor
}
}
new foo();

9. DESTRUCTORS
class foo {
function __construct()
{
echo __METHOD__ . PHP_EOL;
}
function __destruct()
{
echo __METHOD__;
}
}
new foo();
This code will display:
foo::__construct
foo::__destruct

10. VISIBILITY
public
The resource can be accessed from any scope.
protected
The resource can only be accessed from within the class where it is
defined and its descendants.
private
The resource can only be accessed from within the class where it is
defined.
The resource is accessible from any scope, but cannot be
overridden in descendant classes.
final

11. DECLARING AND ACCESSING PROPERTIES
class foo {
public $bar;
protected $baz;
private $bas;
public $var1 = "Test"; // String
public $var2 = 1.23; // Numeric value
public $var3 = array (1, 2, 3);
}

12. CONSTANTS, STATIC METHODS AND
PROPERTIES
class foo {
static $bar = "bat";
public static function baz()
{
echo "Hello World";
}
}
$foo = new foo();
$foo->baz();
echo $foo->bar;
Hello WorldPHP Strict Standards: Accessing static
property foo::$bar as non static in PHPDocument1
on line 17
Strict Standards: Accessing static property
foo::$bar as non static in PHPDocument1 on line 1

13. CLASS CONSTANTS
class foo {
const BAR = "Hello World";
}
echo foo::BAR;

14. INTERFACES AND ABSTRACT CLASSES
•An abstract class essentially defines the basic skeleton of a
specific type of encapsulated entity.
•Interfaces, on the other hand, are used to specify an API that
a class must implement.

15. EXCEPTIONS
• Exceptions provide an error control mechanism that is more fine-grained than
traditional PHP fault handling, and that allows for a much greater degree of control.
• Key differences between “regular” PHP errors and exceptions:
• Exceptions are objects, created (or “thrown”) when an error occurs
• Exceptions can be handled at different points in a script’s execution, and different
types of exceptions can be handled by separate portions of a script’s code
• All unhandled exceptions are fatal
• Exceptions can be thrown from the __construct method on failure
• Exceptions change the flow of the application