iFour

OOPConsultancy
with PHP

web Engineering ||

winter 2017
wahidullah Mudaser  Lecture 09
assignment.cs2017@gmail.com
 OOP in PHP
OUTLINE
 Classes and objects
 Methods and properties
 Scope
 Inheritance
 Static methods and properties
 Constants
 Abstraction
 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 name Method name and body
class A {
function foo () {
echo "foo Createhere!"; new object of class
} A
} 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!";
}
}
$myFirstObject = new A('test');
// print 'test'
 All parameters of the creating of the object are passed to the constructor
Properties
 Class can have unlimited number of properties
class A {
var $bar;
function __construct ($bar) {
$this->bar = $bar;
}
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 can specify default value for a property

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

 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
Scope Example
class A {
private $bar;
public function __construct ($bar) {
$this->bar = $bar;
}
The $bar
public function variable
myPrint ()is{private so only the
object can access it
echo $this->bar;
} 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
 Example of a class constant
class A {
const myConstant = '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 (2)
// continue from previous slide
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($template) {
foreach($this->vars as $name=>$value) {
$template = str_replace(
'{'.$name.'}', $value, $template);
}
return $template;
}
}
Questions?

http://www.ifourtechnolab.com/ ASP.NET Software Development Companies India