0% found this document useful (0 votes)
7 views

OOP-in-php

Uploaded by

menber988
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
7 views

OOP-in-php

Uploaded by

menber988
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 28

CH-6 Object-Oriented

Programming in PHP
OBJECTIVES

• Classes and objects


• Methods and properties
• Scope
• Inheritance
• Static methods and properties
• Constants
• Abstraction and interfaces
CLASSES AND OBJECTS

• The idea of Object Oriented Programming is to move the


architecture of an application closer to real world
• Classes are types of entities
• Objects are single units of a given class
• Example – Dog is a class, your dog Lassie is an object of
class Dog
• Classes have methods and properties
• Classes and objects help to create well-structured
application
CLASSES IN PHP

• Declaring of a class in PHP can be done anywhere in


the code
class Dog {
… // declare methods and properties
}
• Two special methods: constructor and destructor
• Executed when creating or destroying new object of this
class
• Used to initialize or cleanup properties and etc.
CLASSES IN PHP
• Class definition begins with the class keyword, followed
by its name and methods and properties list

class A {
function foo () {
echo "foo here!";
}
} • Objects of class (instances) are created with the keyword
new
$myFirstObject = new A();
$myFirstObject->foo(); // prints out "foo
here!"; Execute method
of this object
CONSTRUCTORS

• Each class can have only one constructor


class A {
function __construct ($bar) {
echo $bar;
}
function foo () {
echo "foo here!";
}
} • All parameters of the creating of the object are passed to
the constructor
$myFirstObject = new A('test');
// print 'test'
PROPERTIES
• Class can have unlimited number of
properties
class A {
var $bar;
function __construct ($arg) {
$this->bar = $arg;
}

function myPrint () {
echo $this->bar;
}
}
$myFirstObject = new A('test');
$myFirstObject->myPrint();
• The $this variable points to the current
object – called execution context
MORE PROPERTIES

class A {
var
• Class can$bar = default
specify 'default
valuevalue';
for a property

• Properties can be accessed from the outside world

class A {
var $bar = 'default value';

}
$obj = new A;
echo $obj->bar;
$THIS
• Example of what $this is
class A {
var $bar;
function __construct ($bar) {
$this->bar = $bar;
}
function myPrint () {
echo $this->bar;
}
}
$myFirstObject = new A('test');
$myFirstObject->myPrint(); // prints 'test'
$anotherObject = new A('foo');
$anotherObject ->myPrint(); // prints 'foo';

• Can be used to access methods too


DESTRUCTORS
• Each class can have only one destructor
• Must be public

class A {
function __construct ($name) {
$this->fp = fopen ($name, 'r');
}
function __destruct () {
fclose($this->fp);
}
}
$myFirstObject = new A('test');

• Destructors are automatically called when script is shutting


down
SCOPE
• Each method and property has a scope
• It defines who can access it
• Three levels – public, protected, private
• Private can be access only by the object itself
• Protected can be accessed by descendant
classes (see inheritance)
• Public can be accessed from the outside world
• Level is added before function keyword or
instead of var
• var is old style (PHP 4) equivalent to public
• Constructors always need to be public
class A { SCOPE EXAMPLE
private $bar;
public function __construct ($bar) {
$this->bar = $bar;
} The $bar varia
public function myPrint () { private so only
echo $this->bar; object can acce
}
} The myPrint method is public, so
everyone can call it
$myFirstObject = new A('test');
$myFirstObject->myPrint(); // prints 'test'
// this will not work:
echo $myFirstObject->bar;
INHERITANCE
• A class can inherit (extend) another class
• It inherits all its methods and properties
class A {
public $bar = 'test';
public function example () {

}
}
class B extends A {

}
$obj = new B();
echo $obj->bar; //prints 'test'
//calls the A-class function
$obj->example();
PROTECTED SCOPE
• Method or property, declared as protected can be
accessed in classes that inherit it, but cannot be
accessed from the outside world
class A {
protected $bar = 'test';
}
class B extends A {
public function foo () {
// this is allowed
$this->bar = 'I see it';
}
}
$obj = new B();
echo $obj->bar; //not allowed
OVERRIDING
• When a class inherits another, it can declare
methods that override parent class methods
• Method names are the same
• Parameters may differ

class A {
public foo() { … }
}
class B extends A {
public foo() { … }
}
OVERRIDING EXAMPLE

class A {
public foo() {
echo 'called from A';
}
}
class B extends A {
public foo() {
echo 'called from B';
}
}
$obj1 = new A();
$obj2 = new B();
$obj1->foo(); // executes A's methods
$obj2->foo(); // executes B's methods
ACCESSING PARENT CLASS

• As -> is used to access object's methods and


properties, the :: (double colon) is used to change
scope
• Scope Resolution Operator
• parent:: can be used to access parent's class
overridden methods
• Example: call parent's constructor in the child one
ACCESSING PARENT CLASS
• Example of calling parent constructor
class A {
protected $variable;
public __construct() {
$this->variable = 'test';
}
}
class B extends A {
public __construct() {
parent::__construct();
echo $this->variable;
}
}
$obj1 = new B();
// prints 'test';
THE STATIC KEYWORD

• Defining method or property as 'static' makes them


accessible without needing an instantiation of a class
• Accessed with the double-colon (::) operator instead of
the member (->) operator
• $this is not available in static methods
• Static properties and methods can also have scope
defined – public, private or protected
THE STATIC KEYWORD
• Example of static method and property

class A {
public static $myVariable;
public static function myPrint() {
echo self::$myVariable;
}
}
A::$myVariable = 'test';
A::myPrint();
• Class can access statics with the self keyword
• Outside world accesses statics with the class name
CLASS CONSTANTS
• Constants in PHP usually are declared with the
define function
• Constants can be defined in class
• Differ from normal variables – no need for $
symbol to declare and access
• Declared with the const keyword
• Value must be supplied with the declaration
• Accessed with scope operator (::)
• Can be overridden by child classes
• Value must be constant expression, not a
variable, class member, result of operation
or function call
CLASS CONSTANTS
class A {
const
• Example of amyConstant
class constant= 'value';

public function showConstant() {


echo self::myConstant;
}
}

echo A::myConstant;

$obj = new A();


$obj->showConstant();
ABSTRACTION

• Classes, defined as abstract, cannot have instances


(cannot create object of this class)
• Abstract class must have at least one abstract method
• Abstract methods do not have implementation (body) in the
class
• Only signature
• The class must be inherited
• The child class must implement all abstract methods
• Cannot increase visibility
ABSTRACTION EXAMPLE
abstract class AbstractClass {
abstract protected function getValue();
abstract public function getValue2($prefix);

public function printOut () {


echo $this->getValue();
}
}
class Class1 extends AbstractClass {
protected function getValue (){
return "Class1";
}
public function getValue2($prefix) {
return $prefix."NAC1";
}
}
ABSTRACTION EXAMPLE
// continue from previous slide
(2)
class Class2 extends AbstractClass {
protected function getValue (){
return "Class2";
}
public function getValue2($prefix) {
return $prefix."NAC2";
}
}

$class1 = new Class1();


$class1->printOut(); // "Class1";
echo $class1->getValue2('FOO'); // FOONAC1

$class2 = new Class2();


$class2->printOut(); // "Class2";
echo $class2->getValue2('FOO'); //FOONAC2
INTERFACES
• Object interfaces allow you to specify what
methods a child class must implement
• Declared with the interface keyword
• Similar to abstract class
• Interface can have only public methods
• No method in interface can have
implementation
• Interfaces are inherited with the implements
keyword (instead of extends)
• One class may implement multiple interfaces,
if they do not have methods with same names
INTERFACE EXAMPLE
interface iTemplate {
public function set ($name, $value);
public function getHTML($template);
}
class Template implements iTemplate {
private $vars = array();
public function set ($name, $value) {
$this->vars[$name] = $value;
}
public function getHTML($ str) {
foreach($this->vars as $name=>$value) {
$ str = str_replace(
$name, $value, $str);
}
return $template;
}
}
28

QUIZ

• Question #1-
• Describe the difference between echo and Print
statements with examples
• Question #2-
• Write a Program in which a function will be created at
run time, calculate an employee current age and years
employed by getting two arguments(dob and date-of-
joining).
• Also display the name of the run time created function.

You might also like