Object-Oriented PHP (2) Further OO Concepts & Practice

1. Object-Oriented PHP (2)Further OO Concepts & Practice

2. Refactoring the Person/Student class (1) (from last week) Person class: class Person { public $name; public $dob; public $gender; function __construct($n, $d, $g){ $this->name = $n; $this->dob = $d; $this->gender = $g; } function get_name(){ return $this->name; } } public by default

3. Refactoring the Person/Student class (2) inheritance or sub-classing (from last week) Student class: class Student extends Person { public $programme; public $number; function __construct($n, $d, $g, $p, $no) { parent::__construct($n, $d, $g); $this->programme = $p; $this->number = $no; } } call parent method

4. Refactoring the Person/Student classes (3) // instantiate a student object $s $s = new Student ('Reuben', '1993/10/25', 'male', 'Systems Analysis', '12345678'); // invoke the get_name() method echo $s->get_name(); Output: Reuben Note on UML 2 notation: + public # protected – private

5. Refactoring the Person/Student/Lecturer classes (4) refactored Person class: date_default_timezone_set('Europe/London'); class Person { private $name, $dob, $gender; function __construct($n, $d, $g) { $this->name = $n; $this->dob = $d; $this->gender = $g; } public function __get($var) { return $this->$var; } public function get_age() { return floor((time() - strtotime($this->dob))/31556926); } } calculates current age

6. Refactoring the Person/Student/Lecturer classes (5) refactored Student class: include_once('Person_Class.php'); class Student extends Person { private $programme; private $number; public function __construct($n, $d, $g, $p, $no) { parent::__construct($n, $d, $g); $this->programme = $p; $this->number = $no; } public function __get($var) { if (preg_match('/name|dob|gender/', $var)) { return parent::__get($var); } return $this->$var; } } overrides parents __get

7. Refactoring the Person/Student/Lecturer classes (6) Lecturer class: include_once('Person_Class.php'); class Lecturer extends Person { private $modules=array(); private $room; function __construct($n, $d, $g, $m, $r) { parent::__construct($n, $d, $g); $this->modules = $m; $this->room = $r; } public function __get($var) { if (preg_match("/name|dob|gender/", $var)) { return parent::__get($var); } return $this->$var; } }

8. Refactoring the Person/Student/Lecturer classes (7) <?php include('Student_Class.php'); include('Lecturer_Class.php'); // instantiate a student object $s $s = new Student ('Reuben', '1993/07/25','male','Systems Analysis', '12345678'); //invoke the __get() method echo $s->name; echo ' is doing '.$s->programme; echo ' and is '.$s->get_age().' years old<br/>'; // instantiate a new Lecturer $l = new Lecturer('Prakash', '1960/09/01','man', array('Web Programming','ISD','PEPI'), '3P16'); // echo name and each array element followed by an & (unless last element) echo $l->name.' teaches '; foreach($l->modules as $module) { echo $module; if (!(end($l->modules)==$module)) {echo ' &amp; ';} } ?> run it

9. Controlling access with private, protected and public • php uses access modifiers to control the visibility of attributes and methods (functions) - these modifiers are placed in front of attributes and methods • the default option is public - that is, if no modifier is stated - it is assumed to be public - these can be accessed from inside or outside the class • the private access modifier can only be accessed from inside the class - if, for instance a method is a utility function and only to be used inside the class - private attributes & methods cannot be inherited • the protected access modifier means that the marked item can be accessed from inside the class but also exists in any inherited classes - protected is kind of half way between public and private

10. class methods, variables & constants (1) • class methods are not run on specific a object instance – • they have class only scope • from outside they have to be called using the class name • the keyword for class methods and variables is static • inside the class the qualifier self:: is used; • outside the class the qualifier Classname:: is used • example: static variable & method • class StaticExample { • static public $aNum = 0; • static public function sayHello() { • echo 'hello'; • } • // from inside the class • echo self::$aNum; • self::sayHello(); • } • // from outside • echo StaticExample::$aNum; • StaticExample::sayHello();

11. class methods, variables & constants (2) example (2): static variable & method class StaticExample { static public $aNum = 0; static public function sayHello() { self::$aNum++; echo 'hello ('.self::$aNum.')<br/>'; } } test_static.php include ('StaticExample.php'); StaticExample::sayHello(); StaticExample::sayHello(); StaticExample::sayHello(); Output? run it no need to instantiate the class

12. class constants : • cannot be changed (hence ‘constant’) • they are always public • some restrictions on what they can hold (no objects for instance) • declared using the constkeyword • not allowed to be defined inside methods class methods, variables & constants (3) example : class HowLong { // speed of light (meters per second) const C = 299792458; // average distance from the earth to the sun (meters) const D = 140000000000; // method to calculate how long light takes to // get from the sun to the earth in minutes function minToEarth() { echo (self::D/self::C)/60; } } HowLong::minToEarth(); run it

13. “final” classes and methods • inheritance is powerful and flexible allowing for sub-classing (specialisation) or overriding methods so that call to a client method will achive radically different results (see our Shape class example from last week) • sometimes though, we require a class or method to remain unchanging – to stop inheritance or overriding • The keyword final puts a stop to inheritance and does not allow methods to be overridden (i.e. you can instantiate a class with a final method but you can’t override that method) • example: • final class Checkout {}; • // try to inherit • class IllegalCheckout extends Checkout { }; • run it • Fatal error: Class IllegalCheckout may not inherit from final class (Checkout) in C:\xampp\htdocs\php\illegal.php on line 5

14. autoloading classes • in php4 classes had to loaded with the include or require keywords • in php5 classes can be loaded dynamically and on a need to use basis by using a “magic” method (or interceptor function) called __autoload • example: • function __autoload($className) { • include_once($className.'_Class.php'); • } • //we have a class called Person_Class.php hence • $person = new Person('Reuben', '1993/07/25','male'); • // will work; hence • echo $person->name; //is fine run it more on “magic” methods next week ….