Remember our last lecture?

http://xkcd.com/327/
Encapsulation, Inheritance, Polymorphism
• Data members
• Methods
 Object Orientation

 PHP is an Object-Oriented programming

language
 Fundamental feature of OO is the class
 PHP classes support
Encapsulation
Inheritance
Polymorphism
 What is a Class?
Classes
 Sophisticated „variable types‟
 Data variables (data members) and functions
(methods) are wrapped up in a class. Collectively,
data members and methods are referred to as class
members.

An instance of a class is known as an object.

//defining a new class named Robot

class Robot {
//place class members here...
}
 Instantiating a class using new
 Once a class has been created, any number of
object instances of that class can be created.
 $dogRobot = new Robot();
 To invoke methods:  e.g.
object->method() <?php
....
$dogRobot = new Robot();
$dogRobot ->crawlWeb();
$dogRobot -> play();
echo $dogRobot ->talk();
...
?>
 Defining classes
<?php
class Person { Data members
private $strFirstname = “Napoleon";
private $strSurname = “Reyes";

function getFirstname() {
return $this->strFirstname;
} Methods
function getSurname() {
return $this->strSurname;
}
}
// outside the class definition
$obj = new Person; // an object of type Person
echo "<p>Firstname: " . $obj->getFirstname() . "</p>";
echo "<p>Surname: " . $obj->getSurname() . "</p>";
?>

Example16-1.php
 Encapsulation
Data members are normally set inaccessible from outside
the class (as well as certain types of methods) protecting
them from the rest of the script and other classes.

This protection of class members is known as

encapsulation.

 e.g.
<?php
....
$dogRobot = new Robot();
$dogRobot ->crawlWeb();
$dogRobot -> play();
echo $dogRobot ->talk();
...
?>
 Inheritance
New classes can be defined very similar to existing ones.
All we need to do is specify the differences between the
new class and the existing one.

Data members and methods which are not defined as

being private to a class are automatically accessible by
the new class.

This is known as inheritance and is an extremely powerful

and useful programming tool.
 Polymorphism
A concept where a number of related classes all have a
method, which shares the same name.

class Fish { draw()... //draws a fish... }

class Dog { draw()... //draws a dog... }
class Bird { draw()... //draws a bird... }

We can write a generic code that can operate on any of

these classes, invoking the appropriate draw() method
based on certain conditions.
 Example: Defining classes
class ShoppingCart {

private $name; // Name of shopper

private $items; // Items in our shopping cart

public function ShoppingCart($inputname) {

$this->name = $inputname;
}

// Add $num articles of $artnr to the cart

public function addItem($artnr, $num) {
$this->items[$artnr] += $num;
}

// Take $num articles of $artnr out of the cart

public function removeItem($artnr, $num) {
if ($this->items[$artnr] > $num) {
$this->items[$artnr] -= $num;
return true;
} elseif ($this->items[$artnr] == $num) {
unset($this->items[$artnr]);
return true;
} else {
return false;
}
} Let‟s examine the syntax of defining a class next...
}
 Data members and Methods
class Class1 {  We need to provide
private $strName = “A”; accessor functions to
private $intNumber = 1; allow users of Class1
function getName() { to access the private
}
data members:
function getNumber(){ function getName(){
} return $this->strName;
} }

Is this publicly accessible?

 $this object pointer
 As with so many languages, there is a special
pointer that references an instance of a class:
$this

function getName(){  function getName(){ 

return strName; return $this->strName;
} }
 Invoking methods inside a class
$this->functionName();
class Person{
...
function setFirstname($strSurname) {
$this->strFirstname = $strSurname;
}

function setSurname($strSurname) {
$this->strSurname = $strSurname;
}

private function display() {

echo "<p>Firstname: " . $this->strFirstname . "</p>";
echo "<p>Surname: " . $this->strSurname . "</p>";
}

function setDisplayFirstnameSurname($strFirstname, $strSurname) {

$this->setFirstname($strFirstname);
$this->setSurname($strSurname);
$this->display();
}
Example16-4.php
}
 Classes
class MyClassName{  Visibility of a method
....methods or data member:
Public
....data members
Protected
}
Private

By default, without
the access specifiers,
class members are
defined public.
 Private Access Specifier
class MyClassName{
private $strFirstName;
}

 private – limits the

visibility of the methods
and data members only
to the class that defines
them.
 Modifying data members
 intNumber is private
 Outside the class, trying to execute
the following:
$clMyObj->intNumber++;
 will fail!...
 We need a method to access and change its
value:
function setNumber($intNumber) {
$this->intNumber = $intNumber;
} Look at the position of the dollar sign ($) – no
longer attached to the variable name
 Public Access Specifier
class MyClassName{
public $strFirstName;
public function getFirstName(){
}
}  public – class
members can be
accessed both within
and outside the
class.
 Protected Access Specifier
//protected for public use, but accessible in a
Class MyClassName{ derived class

protected $strFirstName;
protected function getFirstName(){
}
 Inherited protected class members –
} accessible inside a derived class
 Visibility of protected class
members outside the class definition
– protected class members are
inaccessible.
PROPERTY DECLARATION
 Example: Access Specifiers
<?php
class MyClass {
public $public = 'Public';
protected $protected = 'Protected'; //protected for public use, but accessible in a derived class
private $private = 'Private';

function printHello() {
echo $this->public;
echo $this->protected;
echo $this->private;
}
}
// outside the class definition
$obj = new MyClass();
echo $obj->public; // Works 
echo $obj->protected; // Fatal Error 
echo $obj->private; // Fatal Error 
$obj->printHello(); // Shows Public, Protected and Private
//...

http://php.net/manual/en/language.oop5.visibility.php
 Example: Access Specifiers
<?php a Derived class
//...
class MyClass2 extends MyClass
{
// We can redeclare the public and protected method, but not private
// protected – „protected‟ for public use, but accessible in a derived class
protected $protected = 'Protected2';

function printHello()
{
echo $this->public;
echo $this->protected;
echo $this->private;
}
}
// outside the class definition


$obj2 = new MyClass2();
echo $obj2->public; // Works
echo $obj2->private; // Undefined 
echo $obj2->protected; // Fatal Error 
$obj2->printHello(); // Shows Public, Protected2, Undefined 
?> http://php.net/manual/en/language.oop5.visibility.php
METHOD DECLARATION
 Example: Method Declaration
<?php //OUTSIDE THE CLASS DEFINITION...
class MyClass
{ $myclass = new MyClass;
// Declare a public constructor
public function __construct() { }
$myclass->MyPublic(); // Works

$myclass->MyProtected(); // Fatal Error

$myclass->MyPrivate(); // Fatal Error 
// Declare a public method
public function MyPublic() { }
$myclass->Foo(); // Public, Protected and Private work
//...

// Declare a protected method
protected function MyProtected() { }

// Declare a private method

private function MyPrivate() { }

// This is public
function Foo()
{
$this->MyPublic();
$this->MyProtected();
$this->MyPrivate();
}
}
http://php.net/manual/en/language.oop5.visibility.php
 Example: Method Declaration
<?php class MyClass2 extends MyClass
class MyClass {
{ // This is public
// Declare a public constructor
public function __construct() { }
function Foo2()
{
// Declare a public method $this->MyPublic();
public function MyPublic() { } $this->MyProtected();
$this->MyPrivate(); // Fatal Error
// Declare a protected method }
protected function MyProtected() { } }
// Declare a private method
$myclass2 = new MyClass2;
private function MyPrivate() { }

// This is public
$myclass2->MyPublic(); // Works  
$myclass2->Foo2(); // Public and Protected work, not Private 
function Foo()
{
$this->MyPublic();
$this->MyProtected();
$this->MyPrivate();
}
}

http://php.net/manual/en/language.oop5.visibility.php
 Example: Method Declaration
<?php
class Bar
{
public function test() {
$this->testPrivate();
$this->testPublic();
}
$myFoo = new foo();

public function testPublic() {
echo "Bar::testPublic\n"; $myFoo->test(); // Bar::testPrivate
}

private function testPrivate() {

?>
// Foo::testPublic

echo "Bar::testPrivate\n";
}
}

class Foo extends Bar

{
public function testPublic() {
echo "Foo::testPublic\n";
}

private function testPrivate() {

echo "Foo::testPrivate\n";
}
}
http://php.net/manual/en/language.oop5.visibility.php
 Accessing Private Members of
the same object type
<?php
class Test
{ Objects of the same type will have access to each others
private $foo;
Private and protected members even though they are
public function __construct($foo) not the same instances.
{
$this->foo = $foo;
string(5) "hello"

}
private function bar() Accessed the private method
{
echo 'Accessed the private method.';
}

public function baz(Test $other)

{
// We can change the private property:
$other->foo = 'hello';
var_dump($other->foo);
// We can also call the private method:
$other->bar();
}
}

$test = new Test('test');

$test->baz(new Test('other'));
?>
http://php.net/manual/en/language.oop5.visibility.php
 Creating objects
•Instantiate classes using new keyword
–$myCart= new ShoppingCart(“Charlie”);

Constructors
–In earlier versions of PHP (< PHP5.3.3) Same as the
name of the class. This no longer holds!
– (PHP5 only) declared as
• public function __construct(…)

Destructors
–Declared as
–public function __destruct()
 22 Sept. 2010

Latest in PHP5.3.3

<?php
namespace Foo;
class Bar {
public function Bar() {
// treated as constructor in PHP 5.3.0-5.3.2
// treated as regular method in PHP 5.3.3
}
}
?>
 Constructors
 A constructor is a function that does
initializations when the class is instantiated
function __construct($intNumber, $strName){
$this->set_intNumber($intNumber);
$this->set_strName($strName);
$this->printInit();//use this method
}
 Constructors
 Default arguments
function __construct ($strName = “A”, $intNumber=0) {
$this->set_intNumber($int_Number);
$this->set_strName($str_Name);
}
 Instantiating a class without parameters will
make use of the default values
 Another Example: Constructors
<?php
class vehicle {

private $strDescription;

function getDescription() {
return $this->strDescription;
}

function setDescription($strDescription) {
$this->strDescription = $strDescription;
}

function __construct ($strDescription) {

$this->strDescription = $strDescription;
}
}
?>
vehicle.php
 Another Example: Constructors
<?php

require_once("vehicle.php");

$objBike = new vehicle("Bicycle");

echo "<p>Vehicle: " . $objBike->getDescription() . "</p>";

?>

example16-7.php
 Destructors
 Called when objects are destroyed – free up
memory
 e.g.:
function __destruct () {
echo “freeing up memory, destroying this object... <br>”;
}

This sample code above simply informs us that the object is

being destroyed already.
 Objects as variables
 Can be used in arrays
 Can be passed to functions
 Passed as reference all the time (PHP 5)
 e.g.:
function test1($objClass1){
$objClass1->set_intName(“B”);
}
 No need to use & in the formal parameter
definition. It is always passed by reference.
 Arrays and objects
<?php
function __autoload($class_name) {
require_once $class_name . '.php';
}
$objSimon = new revisedperson("Simon", "Stobart");
$objLiz = new revisedperson("Liz", "Hall");
$objIan = new revisedperson("Ian", "Walker");
$objBilly = new revisedperson("Billy", "Lee");
$objHayley = new revisedperson("Hayley", "West");

$arrPeople = array($objSimon, $objLiz, $objIan, $objBilly, $objHayley);

foreach($arrPeople as $objThePerson){
echo($objThePerson->display());
}
?>
example16-9.php

The function display() is common to all array elements

(elements = objects in this example).
 Multiple Object Instances

<?php
$cart1 = new ShoppingCart(“Joe Bloggs”);
$cart1->addItem("10", 1);

$cart2 = new ShoppingCart(“Fred Smith”);

$cart2->addItem("0815", 3);
?>
 Example: Polymorphism
<?php
function __autoload($class_name) {
require_once $class_name . '.php';
}

$objRectangle = new rectangle(100,50, "rectangle.gif");

$objSquare = new square(100, "square.gif");
$objTriangle = new triangle(50,100, "triangle.gif");
$objEllipse = new ellipse(50,100, "ellipse.gif");

$arrShapes = array ($objRectangle,$objSquare,$objTriangle,$objEllipse);

foreach ($arrShapes as $objShape){
$objShape->display();
$objShape->area();
}
?>
Example17-5.php

The functions area() and display() are common to all array

elements, but executes a different formula for each type of object.
• Recommended: Create one PHP
source file per class definition.
• This aids class reuse and script clarity.
 Remember these PHP Constructs?
• require(….)
Includes file specified, terminates on errors
• include(…)
Includes file specified, gives warning on errors

 • require_once(….)
Includes file specified only if it has not already been
included, terminates on errors
• include_once(….)
Includes file specified only if it has not already been
included, gives warning on errors

Really useful but would require you to write a long list of include() or require() statements
at the beginning of each script, one for each class. In PHP5, this is no longer
necessary. You may define an __autoload function!
Example16-6.php
 function __autoload()
• The function is invoked automatically each time a class is
required but has not been defined.

• We can insert this function into our script:

function __autoload($class_name) {
require_once $class_name . '.php';
}

Note: Class_name = File_name

Example16-7.php
 function __autoload()
<?php
function __autoload($class_name) {
require_once $class_name . '.php';
} Class definition comes from
another file.

$objSimon = new person;

$objSimon->setDisplayFirstnameSurname(“Napoleon", “Reyes");
$objBike = new vehicle("Bicycle");
echo "<p>Vehicle: " . $objBike->getDescription() . "</p>";
?>

Example16-7.php
 Exceptions

Like all good OO languages, PHP5 supports the exception

mechanism for trapping and handling “unexpected conditions”

Note: not all exceptions are necessarily errors

Exceptions not supported in PHP4

 Exceptions
Extend the built-in PHP Exception class with your own
exceptions (as in Java)
class MyException extends Exception {
// Redefine the exception so message isn't
optional
public function __construct($message, $code = 0) {
// some code
// make sure everything is assigned properly
parent::__construct($message, $code); To generate an exception
} <?php
Throw new MyException("Message to display");
?>
// custom string representation of object
public function __toString() {
return __CLASS__ . ": $this->message\n";
}

public function customFunction() {

echo "A Custom function for this type of exception\n";
}
}
 Objects can...
 Invoke another
 Be embedded within another object
 Support for:
Inheritance
Scope resolution ( :: operator)
Class abstraction (define a class that does not
instantiate, use “abstract class classname”)
Polymorphism (same function names with different data
/ behaviour)
'==„ to check if two object have the same attributes and values
'===„ to check if two objects are the same instance of the same class
 Advanced OO in PHP
 PHP5 has rich OO support (similar to the Java model)
Single inheritance (multiple inheritance not allowed)
Abstract classes and methods
Interfaces
 PHP is a reflective programming language
Names of functions/classes to be invoked do not have to be hard
wired
 See also documentation at www.php.net
Reflection-Oriented Programming
Normally, instructions are
// without reflection executed and data is
$Foo = new Foo(); processed; however, in some
languages, programs can
$Foo->hello(); also treat instructions as
data and therefore make
reflective modifications.

// with reflection
New in PHP, not properly
$f = new ReflectionClass("Foo"); documented yet!

$m = $f->getMethod("hello"); Program execution could be

modified at run-time.
$m->invoke( $f->newInstance() );

http://en.wikipedia.org/wiki/Reflection_(computer_science)

http://nz2.php.net/manual/en/reflectionclass.newinstance.php
For a complete reference

http://www.php.net