Php object orientation and classes

http://xkcd.com/327/
Remember ourRemember our last lecturelast lecture??

Encapsulation, Inheritance, PolymorphismEncapsulation, Inheritance, Polymorphism

• Data membersData members
• MethodsMethods

Object OrientationObject Orientation

PHPisan Object-Oriented programming
language

Fundamental feature of OO isthe classclass

PHPclassessupport
− Encapsulation
− Inheritance
− Polymorphism

What is aWhat is a ClassClass??
ClassesClasses

SophisticatedSophisticated ‘variable types’‘variable types’

Data variables (data membersdata members) and functions
(methodsmethods) are wrapped up in a class. Collectively,
data members and methods are referred to as classclass
membersmembers.
An instanceinstance of a classof a class is known as an objectobject.
//defining a new class named Robot
class RobotRobot {{
//place class members here...
}}

Instantiating a class usingInstantiating a class using newnew

Once a classhasbeen created, any numberany number of
object instancesof that classcan be created.

$dogRobot = newnew Robot()Robot();

To invoke methods:
− object->->method()

e.g.
<?php
....
$dogRobot ->crawlWeb();
$dogRobot -> play();
echo $dogRobot ->talk();
...
?>

<?php
class Person {
private $strFirstname = “Napoleon";
private $strSurname = “Reyes";
function getFirstname() {
return $this->strFirstname;
}
function getSurname() {
return $this->strSurname;
}
}
// outside the class definition
$obj = newnew Person; // an object of type Person
echo "Firstname: " . $obj->getFirstname() . "";
echo "Surname: " . $obj->getSurname() . "";
?>
Defining classesDefining classes
Data members
Methods
Example16-1.php

EncapsulationEncapsulation
Data membersData members are normally set inaccessible from outside
the class (as well as certain types of methodsmethods) protecting
them from the rest of the script and other classes.
This protection of class members is known as
encapsulationencapsulation.
 e.g.
<?php
....
$dogRobot ->crawlWeb();
$dogRobot -> play();
echo $dogRobot ->talk();
...
?>

InheritanceInheritance
New classesNew classes can be defined very similar to existing onesexisting ones.
All we need to do is specify the differencesdifferences between the
new class and the existing one.
Data membersData members and methodsmethods which are notnot defined as
being privateprivate to a class are automatically accessible by
the new class.
This is known as inheritanceinheritance and is an extremely powerful
and useful programming tool.

PolymorphismPolymorphism
A concept where a number of related classesrelated classes all have a
methodmethod, which shares the same name.
class Fish { draw()...draw()... //draws a fish//draws a fish...... }}
class Dog { draw()...draw()... //draws a dog//draws a dog...... }}
class Bird { draw()...draw()... //draws a bird//draws a bird...... }}
We can write a generic code that can operate on anycan operate on any of
these classes, invoking the appropriate draw()draw() method
based on certain conditions.

Example:Example: Defining classesDefining classes
class ShoppingCart {
private $name; // Name of shoppershopper
private $items; // Items in our shopping cartItems in our shopping cart
public function ShoppingCartShoppingCart($inputname) {
$this->name = $inputname;
}
// Add $num articles of $artnr to the cart
public function addItemaddItem($artnr, $num) {
$this->items[$artnr] += $num;
}
// Take $num articles of $artnr out of the cart
public function removeItemremoveItem($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’sexamine the syntax of defining a classnext...

Data members and MethodsData members and Methods
class Class1Class1 {
private $strName$strName = “A”;
private $intNumber$intNumber = 1;
function getName()Name() {
}
function getNumber()getNumber(){
}
}

We need to provide
accessor functionsto
allow usersof Class1
to accessthe privateprivate
data members:
function getName()getName(){
return $this->this->strNamestrName;
}
Isthispublicly accessible?

$this$this object pointerobject pointer

Aswith so many languages, there isa special
pointer that referencesan instance of a class:
− $this$this
function getName(){
return $this->strName;
}
function getName(){
return strName;
}
 

Invoking methodsInvoking methods inside a classinside a class
class Person{
...
function setFirstname($strSurname) {
$this->strFirstname = $strSurname;
}
function setSurname($strSurname) {
$this->strSurname = $strSurname;
}
private function display() {
echo "Firstname: " . $this->strFirstname . "";
echo "Surname: " . $this->strSurname . "";
}
function setDisplayFirstnameSurname($strFirstname, $strSurname) {
$this->$this->setFirstname($strFirstname);
$this->$this->setSurname($strSurname);
$this->$this->display();
}
}
$this->$this->functionName();
Example16-4.php

ClassesClasses
class MyClassNameMyClassName{
....methods
....data members
}

Visibility of a method
or data member:
− PublicPublic
− ProtectedProtected
− PrivatePrivate
− By defaultBy default, without
the accessspecifiers,
class membersclass members are
defined publicpublic.

PrivatePrivate Access SpecifierAccess Specifier
privateprivate $strFirstName;
}

privateprivate – limitsthe
visibility of the methods
and data members
only to the classthat
definesthem.

Modifying data membersModifying data members

Outside the class, trying to execute
the following:
$clMyObj->intNumber++intNumber++;

will fail!...

We need a method to accessand change
itsvalue:
function setNumber($intNumber) {
$this->intNumber = $intNumber;
}
intNumberintNumber is privateprivate
Look at the position of the dollar sign ($) – no
longer attached to the variable name

PublicPublic Access SpecifierAccess Specifier
publicpublic $strFirstName;
publicpublic function getFirstName()getFirstName(){
}
} 
publicpublic – class
memberscan be
accessed both withinwithin
and outsideand outside the class.

ProtectedProtected Access SpecifierAccess Specifier
Class MyClassNameMyClassName{
protectedprotected $strFirstName;
protectedprotected function getFirstName()getFirstName(){
}
}

InheritedInherited protectedprotected class membersclass members –
accessible inside a derived classderived class

Visibility ofVisibility of protectedprotected class membersclass members
outside the class definitionoutside the class definition – protected
classmembersare inaccessible.
//protected for public use, but accessible in a
derived class

<?php
class MyClass {
public $public = 'Public';
protected $protected = 'Protected'; //protected for public use, but accessible in a derived class
private $private = 'Private';
function printHello()printHello() {
echo $this->public;
echo $this->protected;
echo $this->private;
}
}
$obj = new MyClass();
echo $obj->public; // Works
echo $obj->protected; // Fatal Error
echo $obj->private; // Fatal Error
$obj->printHello(); // Shows Public, Protected and Private
//...
Example:Example: Access SpecifiersAccess Specifiers




http://php.net/manual/en/language.oop5.visibility.php

<?php
//...
class MyClass2 extendsextends 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;
}
}
$obj2 = new MyClass2();
echo $obj2->public; // Works
echo $obj2->private; // Undefined
echo $obj2->protected; // Fatal Error
$obj2->printHello(); // Shows Public, Protected2, Undefined
?>
Example:Example: Access SpecifiersAccess Specifiers



a Derived class

//OUTSIDE THE CLASS DEFINITION...
$myclass = new MyClass;
$myclass->MyPublic(); // Works
$myclass->MyProtected(); // Fatal Error
$myclass->MyPrivate(); // Fatal Error
$myclass->Foo(); // Public, Protected and Private work
//...
<?php
class MyClass
{
// Declare a public constructor
public function __construct() { }
// Declare a public method
public function MyPublic() { }
// 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();
}
}



Example:Example: Method DeclarationMethod Declaration

class MyClass2 extendsextends MyClass
{
// This is public
function Foo2()
{
$this->MyPublic();
$this->MyPrivate(); // Fatal Error
}
}
$myclass2 = newnew MyClass2;
$myclass2->MyPublic(); // Works
$myclass2->Foo2(); // Public and Protected work, not Private
  
<?php
class MyClass
{
// Declare a public constructor
public function __construct() { }
// Declare a public method
public function MyPublic() { }
// Declare a protected method
protected function MyProtected() { }
// Declare a private method
private function MyPrivate() { }
// This is public
function Foo()
{
$this->MyPublic();
$this->MyPrivate();
}
}

$myFoo = new foo();
$myFoo->test(); // Bar::testPrivate
// Foo::testPublic
?>


<?php
class Bar
{
public function test() {
$this->testPrivate();
$this->testPublic();
}
public function testPublic() {
echo "Bar::testPublicn";
}
private function testPrivate() {
echo "Bar::testPrivaten";
}
}
class Foo extends Bar
{
public function testPublic() {
echo "Foo::testPublicn";
}
private function testPrivate() {
echo "Foo::testPrivaten";
}
}

string(5) "hello"
Accessed the private method
Accessing Private Members of theAccessing Private Members of the
same object typesame object type

<?php
class Test
{
private $foo;
public function __construct($foo)
{
$this->foo = $foo;
}
private function bar()
{
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'));
?>
Objectsof the same type will have accessto each others
Private and protected memberseven though they are
not the same instances.

Creating objectsCreating objects
•Instantiate classes using new keyword
–$myCart= newnew ShoppingCart(“Charlie”);
ConstructorsConstructors
–In earlier versions of PHP (< PHP5.3.3PHP5.3.3) Same as the
name of the class. This no longer holds!This no longer holds!
– (PHP5 onlyPHP5 only) declared as
•public function __construct(…)
DestructorsDestructors
–Declared as
–public function __destruct()

Latest in PHPLatest in PHP5.3.35.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
}
}
?>
22 Sept. 2010


A constructorconstructor isa function that does
initializationswhen the classisinstantiated
function __construct(__construct($intNumber, $strName)){
$this->set_intNumber($intNumber);
$this->set_strName($strName);
$this->printInit();//use thismethod
}


Default argumentsDefault arguments
function __construct ($strName = “A”, $intNumber=0) {
$this->set_intNumber($int_Number);
$this->set_strName($str_Name);
}

Instantiating a classwithout parameterswill
make use of the default values

Another Example:Another Example: ConstructorsConstructors
<?php
class vehiclevehicle {
private $strDescription;
function getDescription() {
return $this->strDescription;
}
function setDescription($strDescription) {
$this->strDescription = $strDescription;
}
function __construct ($strDescription) {
$this->strDescription = $strDescription;
}
}
?>
vehicle.php

Another Example:Another Example: ConstructorsConstructors
<?php
require_once("vehicle.php");
$objBike = new vehicle("Bicycle");
echo "Vehicle: " . $objBike->getDescription() . "";
?>
example16-7.php

DestructorsDestructors

Called when objectsare destroyed – free up
memory

e.g.:
function __destruct () {
echo “freeing up memory, destroying thisobject... ”;
}
This sample code above simply informs us that the object is
being destroyed already.

Objects as variablesObjects as variables

Can be used in arrays

Can be passed to functions

Passed as referencePassed as reference all the time (PHP 55)

e.g.:
function test1($objClass1){
$objClass1->set_intName(“B”);
}

No need to use && in the formal parameterin the formal parameter
definition.definition. It isalwayspassed by reference.

Arrays and objectsArrays 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$arrPeople = array(array($objSimon, $objLiz, $objIan, $objBilly, $objHayley));
foreach($arrPeople$arrPeople as $objThePerson){
echo($objThePerson->->display()display());
}
?>
The function display()display() is common to all array elements
(elements = objects in this example).
example16-9.php

Multiple Object InstancesMultiple Object Instances
<?php
$cart1 = new ShoppingCart(“Joe Bloggs”);
$cart1->addItem("10", 1);
$cart2 = new ShoppingCart(“Fred Smith”);
$cart2->addItem("0815", 3);
?>

Example:Example: PolymorphismPolymorphism
<?php
function __autoload($class_name) {
}
$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();
}
?>
The functions area() and display() are common to all array
elements, but executes a different formula for each type of object.
Example17-5.php

• Recommended: Create one PHP
source file per classdefinition.
• Thisaidsclassreuse and script clarity.

Remember these PHP Constructs?Remember these PHP Constructs?
• require(….)require(….)
− Includesfile specified, terminatesterminates on errors
• include(…)include(…)
− Includesfile specified, gives warningwarning on errors
• require_once(….)require_once(….)
− Includesfile specified only if it hasnot already been
included, terminatesterminates on errors
• include_once(….)include_once(….)
− Includesfile specified only if it hasnot already been
included, gives warningwarning on errors
Example16-6.php

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!

functionfunction __autoload()__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:
Example16-7.php
function __autoload__autoload($class_name) {
require_oncerequire_once $class_name . '.php';
}
Note: Class_name = File_name

functionfunction __autoload()__autoload()
Example16-7.php
<?php
function __autoload__autoload($class_name) {
}
$objSimon = newnew person;
$objSimon->setDisplayFirstnameSurname(“Napoleon", “Reyes");
$objBike = newnew vehicle("Bicycle");
echo "Vehicle: " . $objBike->getDescription() . "";
?>
Classdefinition comesfrom
another file.

ExceptionsExceptions
Like all good OO languages, PHP5 supports the exception
mechanism for trapping and handling “unexpected conditionsunexpected conditions”
Note: not all exceptions are necessarily errors
Exceptions not supported in PHP4

classclass MyExceptionMyException extendsextends 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);
}
// custom string representation of object
public function __toString() {
return __CLASS__ .. ": $this->messagen";
}
public function customFunction() {
echo "A Custom function for this type of exceptionn";
}
}}
Extend the built-in PHP Exception class with your ownExtend the built-in PHP Exception class with your own
exceptions (as in Java)exceptions (as in Java)
ExceptionsExceptions
<?php
Throw new MyExceptionMyException("Message to display");
?>
To generate an exception

Objects can...Objects can...

Invoke another

Be embedded within another object

Support for:
− Inheritance
− Scope resolution ( :::: operator)
− Classabstraction (define a classthat doesnot
instantiate, use “abstractabstract classclass classnameclassname” )
− Polymorphism (same function nameswith different
data / behaviour)
− '====‘ to check if two object have the same attributesand values
− '======‘ to check if two objectsare the same instance of the same class

Advanced OO in PHPAdvanced OO in PHP

PHP5 hasrich OO support (similar to the Java model)
− Single inheritance (multiple inheritance not allowed)
− Abstract classesand methods
− Interfaces

PHPisa reflective programming language
− Namesof functions/classesto be invoked do not have to be hard
wired

See also documentation at www.php.netwww.php.net

Reflection-Oriented ProgrammingReflection-Oriented Programming
// without reflection// without reflection
$Foo = new Foo();
$Foo->hello();
// with reflection// with reflection
$f = new ReflectionClassReflectionClass("Foo");
$m = $f->getMethod("hello");
$m->invoke( $f->newInstance() );
Normally, instructions are
executed and data is
processed; however, in some
languages, programs can
also treat instructions asinstructions as
datadata and therefore make
reflective modifications.
http://en.wikipedia.org/wiki/Reflection_(computer_science)
Program execution could
be modified at run-time.
New in PHP, not properly
documented yet!
http://nz2.php.net/manual/en/reflectionclass.newinstance.php

For a complete reference
http://www.php.net

Php object orientation and classes

More Related Content

What's hot

Viewers also liked

Similar to Php object orientation and classes

More from Kumar

Recently uploaded

Php object orientation and classes