Object-Oriented PHP (1)

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

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

- 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

- 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

- 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’

- 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

- 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; }

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){

- 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/>”; }

- 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

- 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

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?

- 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; }

- 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;

- 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

- 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; }

- 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