Mastering Object-Oriented PHP Development

1. Object-Oriented PHP (1)

2. Key topics: • Object-oriented concepts • Classes, attributes and operations • Class attributes • Per-class constants • Class method invocation • Inheritance • Access modifiers • Static methods • Type hinting • Late static bindings • Object cloning • Abstract classes • Class design • Implementing design • Advanced OO functionality

3. - understanding Object-oriented concepts • many modern programming languages either require (java, ruby, smalltalk etc.) or support (php, perl, F# etc.) the o-o approach to software development. • Object-oriented development attempts to use the classifications, relationships, and properties of the “objects” in the system to aid in program development and code reuse.

4. - classes and objects (1) • in o-o terminology, an “object” can represent something “real” (e.g. an user) or something “conceptual” (e.g. a file) • o-o software is designed and built as a set of self-contained objects that have both attributes (properties) and operations (behaviours) that interact with other objects (with attributes and behaviours) - A major advantage of o-o software is its capability to support and encourage encapsulation – or data hiding. Essentially, access to the data within an object is only available via an objects operations – known as the objects interface

5. - classes and objects (2) • an objects functionality is bound to the data it uses • it is possible alter the internals of an object to improve performance, add new features etc. without altering its interface • hence, an o-o approach can help manage complexity; increase code reusability and thereby reduce maintenance costs • objects can be grouped into “classes” – a class can be thought of as a template for objects of that type

6. - polymorphism • polymorphism is taken from the Greek and means ‘many forms’ • in o-o programming it usually refers to a method (function) or operator that can have the same name but can behave differently in different contexts • for instance an abstract class called ‘shape’ might have a method called ‘area’ which will be implemented in one way in an object called ‘circle’ and in another way in an object called ‘square’

7. - inheritance • inheritance allows for the building of hierarchical relationships between classes using subclasses • a subclass inherits attributes and operations from its superclass • with inheritance it is possible to extend existing classes and thereby derive more complex and specialised classes • it also allows for common operations to be put once in the superclass rather than many times in separate subclasses

8. - creating classes, attributes & operations in PHP • structure of a class a minimal class definition class classname { } • however, to be useful a class needs attributes and operations • attributes are created using keywords that match their visibility : public, private or protected • the following code creates a class with two public attributes class person { public $name; public $age; }

9. operations or methods are created by declaring functions within the class definition • the following code creates a class named classname that do nothing • the first operation op1() takes no parameters and the second op2() takes two parameters class classname { function op1() { } function op2 ($param1, $param2){ } }

10. - constructors • most classes have a special operation called a constructor - which is always called when an object of that class is created • a constructor is like other operations (methods) but has the special name _construct() • the following code defines a class with a constructor class classname { function _construct($param) { echo “Constructor called with parameter ”.$param.“<br/>”; } }

11. - destructors • the opposite of a constructor is a destructor • this allows for some functionality to be executed just before an object is destryed • this will happen automatically when all references to a class have been unset or fallen out of scope • a destructor for a class must be named _destruct() • a destructor cannot take parameters

12. - instantiating classes • after a class has been declared - an object can be created of that class • such an object is an “instantiation” of that class (a particular individual that is a member of that class) • objects are created using the new keyword • when the object is created any parameters required by the _construct method (operation) can be provided - the following code creates a class called classname with a constructor that expects one parameter - then three objects of that class are created

13. class classname { function _construct($param) { echo “conctruct called with”.$param.“<br/>”; } } $a = new classname(“First”); $b = new classname(“Second”); $c = new classname(); what will be the output?

14. - using class attributes (1) • within a class, attributes can be accessed using the special pointer $this • for instance an attribute called $attribute can be accessed with $this—>attribute • the following code illustrates setting and accessing an attribute within a class class classname { public $attribute; function operation($param) { $this—>attribute = $param; echo $this—>attribute; } }

15. - using class attributes (2) • weather an attribute can be accessed from outside a class is determined by access modifiers • however, it is generally not recommended that attributes are accessed directly from outside the class - this is because the o-o approach encourages data hiding or encapsulation • this is done using the __get & __set access functions; e.g. class classname { public $attribute; function __get($name) { return $this—>name; } function __set($name, $value) { $this—>name = value; } }

16. - using class attributes (3) • the previous code example shows two interfaces to the $attribute attribute • the __get() function simple returns the value of $attribute and __set() function assigns a new value to $attribute note that __get() takes one parameter - the name of an attribute and the __set() function takes two parameters - the name of an attribute and the value it is to be set to • also note the use of the double underscore as in the __construct() and __destruct() functions • php gives these functions special meaning and the __get() and __set() functions can be now be used to get and set the value of any attribute, e.g. $a = new classname; $a—>attribute = 5; // this will implicitly call the // set function on the attribute // called $attribute

17. - why bother? • with a single access point (interface) it is now easy to implement validity checks • for instance, if we now wanted to ensure that $attribute always has to be between 1 and 100 - we only need to modify the code in one place function __set($name, $value) { if (($name==“attribute” && ($value >= 1) && ($value <= 100) $this—>attribute = $value; }

18. - controlling access with private 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 only be accessed from inside the class but also exists in any inherited classes - protected is kind of half way between public and private