Object Oriented Programming in PHP

iFour ConsultancyOOP with PHP
web Engineering ||
winter 2017
wahidullah Mudaser
assignment.cs2017@gmail.com
 Lecture 09
 OOP in PHP

 Classes and objects
 Methods and properties
 Scope
 Inheritance
 Static methods and properties
 Constants
 Abstraction
 interfaces
OUTLINE

 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 and objects

 Declaring of a class in PHP can be done anywhere in the code.
 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 Dog {
… // declare methods and properties
}

Classes in PHP
 Class definition begins with the class keyword, followed by its name and
methods and properties list
 Objects of class (instances) are created with the keyword new
class A {
function foo () {
echo "foo here!";
}
}
$myFirstObject = new A();
$myFirstObject->foo(); // prints out "foo here!";
class name Method name and body
Create new object of class
A
Execute method of this
object

Constructors
 Each class can have only one constructor
 All parameters of the creating of the object are passed to the constructor
class A {
function __construct ($bar) {
echo $bar;
}
function foo () {
echo "foo here!";
}
}
$myFirstObject = new A('test');
// print 'test'

Properties
 Class can have unlimited number of properties
 The $this variable points to the current object – called execution
context
class A {
var $bar;
$this->bar = $bar;
}
function myPrint () {
echo $this->bar;
}
}
$myFirstObject->myPrint();

More Properties
 Class can specify default value for a property
 Properties can be accessed from the outside world
class A {
var $bar = 'default value';
…
class A {
var $bar = 'default value';
…
}
$obj = new A;
echo $obj->bar;

$this
 Example of what $this is
 Can be used to access methods too
class A {
var $bar;
$this->bar = $bar;
}
function myPrint () {
echo $this->bar;
}
}
$myFirstObject->myPrint(); // prints 'test'
$anotherObject = new A('foo');
$anotherObject ->myPrint(); // prints 'foo';

Destructors
 Each class can have only one destructor
 Must be public
 Destructors are automatically called when script is shutting down
class A {
function __construct ($name) {
$this->fp = fopen ($name, 'r');
}
function __destruct () {
fclose($this->fp);
}
}

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;
}
public function myPrint () {
echo $this->bar;
}
}
$myFirstObject->myPrint(); // prints 'test'
// this will not work:
echo $myFirstObject->bar;
The $bar variable is private so only the
object can access it
The myPrint method is public, so
everyone can call it

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 can access statics with the self keyword
 Outside world accesses statics with the class name
class A {
public static $myVariable;
public static function myPrint() {
echo self::$myVariable;
}
}
A::$myVariable = 'test';
A::myPrint();

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

Object Oriented Programming in PHP

More Related Content

What's hot

Similar to Object Oriented Programming in PHP

More from wahidullah mudaser

Recently uploaded

Object Oriented Programming in PHP