UFCEUS-20-2 : Web Programming Lecture 5 : Object Oriented PHP (1)

o simplicity: software objects model real world objects, so the complexity is reduced and the program structure is very clear; o modularity: each object forms a separate entity whose internal workings are decoupled from other parts of the system; o modifiability: it is easy to make minor changes in the data representation or the procedures in an OO program. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods; o extensibility: adding new features or responding to changing operating environments can be solved by introducing a few new objects and modifying some existing ones; o maintainability: objects can be maintained separately, making locating and fixing problems easier; o re-usability: objects can be reused in different programs. strong cohesion loose coupling abstraction encapsulation the object-oriented approach

many modern programming languages either require (java, ruby, smalltalk etc.) or support (php, perl, F# etc.) the oo 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. the oo approach can be compared and contrasted with other approaches to programming – e.g. imperative, procedural, functional, logical, event-driven, declarative, aspect-oriented ….

o in oo terminology, an “object” can represent something “real” (e.g. an user) or something “conceptual” (e.g. a file) o o oo 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) o 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 (1)

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

creating classes and class structure o structure of a class : a minimal class definition o class Classname { } o however, to be useful a class needs attributes (properties) and operations (methods) o attributes (properties) are created using keywords that match their visibility : public, private or protected o the following code creates a class with three public attributes class Person { public $name; public $dob; public $gender; }

o operations or methods are created by declaring functions within the class definition o the following code extends the Person class with two operations (methods) set_name and get_name o the first method takes 1 parameter and the second takes none but operations can take 0 to any number of parameters class Person { function set_name($name) { $this->name = $name; } function get_name(){ return $this->name; } class level operations and methods

o most classes have a special operation called a constructor - which is always called when an object of that class is created o a constructor is like other operations (methods) but has the special name __ construct() [note the double underscores __ ] o the following code re-defines the Person class with a constructor class Person { function __construct($n, $d, $g){ $this->name = $n; $this->dob = $d; $this->gender = $g; } constructors

instantiating classes o after a class has been declared - an object can be created of that class o such an object is an “instantiation” of that class (a particular individual that is a member of that class) o objects are created using the new keyword o when the object is created any parameters required by the __ construct method (operation) can be provided o - the following code uses our Person class passing it the expected parameters to creates three Person objects …

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; } # create two objects $p1 = new Person (‘Anna’, ‘11/10/83’, ‘woman’); $p2 = new Person (‘James’, ‘02/10/81’, ‘man’); # call the get_name() method echo $p1->get_name().’ ’; echo $p2->get_name(); instantiating the person class, creating two person objects & calling the get_name() method run script

controlling access with private, protected and public o php uses access modifiers to control the visibility of attributes and methods (functions) - these modifiers are placed in front of attributes and methods o 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 o 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 o 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

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

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

new class Student inheriting from the Person class class Student extends Person { public $programme; public $number; public function __construct($n, $d, $g, $p, $no) { parent::__construct($n, $d, $g); $this->programme = $p; $this->number = $no; } function get_programme(){ return $this->programme; } function get_number(){ return $this->number; } $s = new Student (‘Reuben’, ’25/08/93’, ‘male’, ‘Systems Analysis’, ‘ ’); echo $s->get_name(); echo $s->get_programme(); Run

abstract classes o abstract classes allow us to define base functionality that all child classes must implement o they can define concrete base functions as well as abstract functions that bind child classes to a contract o abstract classes cannot be instantiated – e.g. you cannot have a abstract class called Person and then instantiate a new Person object o one abstract class can be extended by another abstract class

abstract class Shape { public abstract function area(); } class Circle extends Shape { private $radius; public function __construct($r) { $this->radius = $r; } public function area() { return $this->radius * $this->radius * pi(); } abstract class example

class Rectangle extends Shape { private $length; private $width; public function __construct($l, $w) { $this->length = $l; $this->width = $w; } public function area() { return $this->length * $this->width; } $c = new Circle(22); echo "Area of the circle: ". $c->area(). " "; $r = new Rectangle(5, 7); echo "Area of the rectangle: ". $r->area(). " "; abstract class example (cont.) Run

polymorphism o polymorphism is taken from the Greek and means ‘many forms’ o in oo programming it usually refers to a method (function) or operator that can have the same name but can behave differently in different contexts o for instance in the previous example the abstract class called ‘shape’ has a method called ‘area’ which is implemented in one way in the object called ‘circle’ and in another way in the object called ‘rectangle’

resources Introduction to PHP Objects, Part 1 Introduction to PHP Objects, Part 1 : John Coggeshall Introduction to PHP Objects, Part 2 Introduction to PHP Objects, Part 2 : John Coggeshall Getting started with objects with PHP V5 Getting started with objects with PHP V5 : Matt Zandstra