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

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) 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; } (from last week) Student class: inheritance or sub-classing call parent method

4. Note on UML 2 notation: + public # protected – private // 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(); //filters up to parent Output: Reuben Refactoring the Person/Student classes (3)

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. <?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 '; // 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 ' & ';} } ?> Refactoring the Person/Student/Lecturer classes (7) 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 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 method & variable example (2): static variable class StaticExample { static public $aNum = 0; static public function sayHello() { self::$aNum++; echo 'hello ('.self::$aNum.') '; } test_static.php include ('StaticExample.php'); StaticExample::sayHello(); Output? run itrun it no need to instantiate the class

12. class method & constant 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 const keyword not allowed to be defined inside methods 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 { }; Output: 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 ….