Download
1 / 14
140 likes | 259 Views
This tutorial delves into advanced object-oriented concepts in PHP by focusing on the refactoring of the Person and Student classes. It showcases how to utilize inheritance to create a streamlined design, incorporating features such as constructor overloading, private and protected variables, and method overriding. The example code is designed to solidify your understanding of encapsulation, access modifiers, and the advantages of class structuring in a practical context. Ideal for developers looking to enhance their OO PHP skills.
E N D
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
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
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
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
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
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; } }
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 ' & ';} } ?> run it
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
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();
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
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
“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
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 ….
