Object-Oriented Programming in PHP

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

8. More Properties class A { var $bar = 'default value'; … • 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 • 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'; • Example of what $this is • Can be used to access methods too

10. 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); } } $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 • 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 • 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() { … } }

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

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 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'; • Example of calling parent constructor

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