1. Object-Oriented Programming in PHP

2. Objectives Classes and objects Methods and properties Scope
Inheritance
Static methods and properties
Constants
Abstraction and interfaces

3. 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

4. Classes in PHP class Dog { … // declare methods and properties }
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.
class Dog {
… // declare methods and properties }

5. Classes in PHP Method name and body class name
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
Method name and body
class name
class A {
function foo () {
echo "foo here!"; } }
$myFirstObject = new A();
$myFirstObject->foo(); // prints out "foo here!";
Create new object of class A
Execute method of this object

6. Constructors class A { function __construct ($bar) { echo $bar; }
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'

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

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

9. $this Example of what $this is class A { var $bar;
Can be used to access methods too
$this
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';

10. Destructors Each class can have only one destructor class A {
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); }
$myFirstObject = new A('test');

11. 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

12. Scope Example
class A {
private $bar;
public function __construct ($bar) {
$this->bar = $bar; }
public function myPrint () {
echo $this->bar; }
$myFirstObject = new A('test');
$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

13. Inheritance A class can inherit (extend) another class class A {
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();

14. 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

15. Overriding class A { public foo() { … } } class B extends A {
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 {

16. Overriding Example class A { public foo() { echo 'called from A'; }
class B extends A {
echo 'called from B';
$obj1 = new A();
$obj2 = new B();
$obj1->foo(); // executes A's methods
$obj2->foo(); // executes B's methods

17. 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

18. Accessing Parent Class
Example of calling parent constructor
class A {
protected $variable;
public __construct() {
$this->variable = 'test'; }
class B extends A {
parent::__construct();
echo $this->variable;
$obj1 = new B();
// prints 'test';

19. 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

20. The static Keyword Example of static method and property class A {
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();

21. 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

22. Class Constants class A { const myConstant = 'value';
public function showConstant() {
echo self::myConstant; } }
echo A::myConstant;
$obj = new A();
$obj->showConstant();
Example of a class constant

23. 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

24. 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"; }

25. 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

26. 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

27. 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- Question #2-
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.