24094382 OOPS Concepts in PHP

7/31/2019 24094382 OOPS Concepts in PHP

1/40

Introduction

Starting with PHP 5, the object model was rewritten to allow for better performance and more features.This was a major change from PHP 4. PHP 5 has a full object model.

Among the features in PHP 5 are the inclusions of visibility, abstract and final classes and methods,

additional magic methods, interfaces, cloning and typehinting.PHP treats objects in the same way as references or handles, meaning that each variable contains anobject reference rather than a copy of the entire object. See Objects and References

Classes and Objects

Introduction

The Basics

Properties Class Constants

Autoloading Classes

Constructors and Destructors

Visibility

Object Inheritance

Scope Resolution Operator (::)

Static Keyword

Class Abstraction

Object Interfaces

Overloading

Object Iteration

Patterns

Magic Methods

Final Keyword

Object Cloning

Comparing Objects

Type Hinting

Late Static Bindings

Objects and references

Object Serialization


2/40

Class

Every class definition begins with the keyword class, followed by a class name, followed by a pair ofcurly braces which enclose the definitions of the class's properties and methods.

The class name can be any valid label which is a not a PHP reserved word. A valid class name startswith a letter or underscore, followed by any number of letters, numbers, or underscores. As a regular

expression, it would be expressed thus: [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*.

A class may contain its own constants, variables (called "properties"), and functions (called"methods").

The pseudo-variable $this is available when a method is called from within an object context. $this is areference to the calling object (usually the object to which the method belongs, but possibly anotherobject, if the method is called statically from the context of a secondary object).


3/40

}

$a = new A();$a->foo();

// Note: the next line will issue a warning if E_STRICT is enabled.A::foo();$b = new B();$b->bar();

// Note: the next line will issue a warning if E_STRICT is enabled.B::bar();?>

New

To create an instance of a class, a new object must be created and assigned to a variable. An object willalways be assigned when creating a new object unless the object has a constructor defined that throws

an exception on error. Classes should be defined before instantiation (and in some cases this is arequirement).

In the class context, it is possible to create a new object by new self and new parent.

When assigning an already created instance of a class to a new variable, the new variable will accessthe same instance as the object that was assigned. This behaviour is the same when passing instances toa function. A copy of an already created object can be made by cloning it.

Extends

A class can inherit the methods and properties of another class by using the keyword extends in theclass declaration. It is not possible to extend multiple classes; a class can only inherit from one baseclass.

The inherited methods and properties can be overridden by redeclaring them with the same namedefined in the parent class. However, if the parent class has defined a method as final, that method maynot be overridden. It is possible to access the overridden methods or static properties by referencingthem with parent::


4/40

{ // Redefine the parent method function displayVar()

{echo "Extending class\n";

parent::displayVar();}

}

$extended = new ExtendClass();$extended->displayVar();?>


5/40

Properties

Class member variables are called "properties". You may also see them referred to using other termssuch as "attributes" or "fields", but for the purposes of this reference we will use "properties". They aredefined by using one of the keywords public, protected, or private, followed by a normal variabledeclaration. This declaration may include an initialization, but this initialization must be a constantvalue--that is, it must be able to be evaluated at compile time and must not depend on run-timeinformation in order to be evaluated.

See Visibility for more information on the meanings of public, protected, and private.

Note: In order to maintain backward compatibility with PHP 4, PHP 5 will still accept theuse of the keyword var in property declarations instead of (or in addition to) public,protected, or private. However, var is no longer required. In versions of PHP from 5.0 to5.1.3, the use of var was considered deprecated and would issue an E_STRICT warning,but since PHP 5.1.3 it is no longer deprecated and does not issue the warning.If you declare a property using var instead of one of public, protected, or private, then PHP5 will treat the property as if it had been declared as public.

Within class methods the properties, constants, and methods may be accessed by using the form $this->property (where property is the name of the property) unless the access is to a static property withinthe context of a static class method, in which case it is accessed using the form self::$property. SeeStatic Keyword for more information.

The pseudo-variable $this is available inside any class method when that method is called from withinan object context. $this is a reference to the calling object (usually the object to which the methodbelongs, but possibly another object, if the method is called statically from the context of a secondaryobject).


6/40

Class Constants

It is possible to define constant values on a per-class basis remaining the same and unchangeable.Constants differ from normal variables in that you don't use the $ symbol to declare or use them.

The value must be a constant expression, not (for example) a variable, a property, a result of a

mathematical operation, or a function call.Its also possible for interfaces to have constants. Look at the interface documentation for examples.

As of PHP 5.3.0, it's possible to reference the class using a variable. The variable's value can not be akeyword (e.g. self, parent and static).

EXAMPLE := const constant = 'constant value';


7/40

Autoloading Classes

Many developers writing object-oriented applications create one PHP source file per-class definition.One of the biggest annoyances is having to write a long list of needed includes at the beginning of eachscript (one for each class).

In PHP 5, this is no longer necessary. You may define an __autoload function which is automaticallycalled in case you are trying to use a class/interface which hasn't been defined yet. By calling thisfunction the scripting engine is given a last chance to load the class before PHP fails with an error.

Note: Exceptions thrown in __autoload function cannot be caught in the catch block andresults in a fatal error.

Note: Autoloading is not available if using PHP in CLI interactive mode.

Note: If the class name is used e.g. in call_user_func() then it can contain some dangerouscharacters such as ../. It is recommended to not use the user-input in such functions or atleast verify the input in__autoload().

?phpfunction __autoload($class_name) {

require_once $class_name . '.php';}

$obj = new MyClass1();$obj2 = new MyClass2();?>


8/40

Constructors and Destructors

Constructor

void__construct ([ mixed$args [, $... ]] )

PHP 5 allows developers to declare constructor methods for classes. Classes which have a constructormethod call this method on each newly-created object, so it is suitable for any initialization that theobject may need before it is used.

Note: Parent constructors are not called implicitly if the child class defines a constructor. Inorder to run a parent constructor, a call to parent::__construct() within the childconstructor is required.

For backwards compatibility, if PHP 5 cannot find a__construct() function for a given class, it willsearch for the old-style constructor function, by the name of the class. Effectively, it means that theonly case that would have compatibility issues is if the class had a method named__construct() whichwas used for different semantics.

Destructor

void__destruct ( void )

PHP 5 introduces a destructor concept similar to that of other object-oriented languages, such as C++.The destructor method will be called as soon as all references to a particular object are removed orwhen the object is explicitly destroyed or in any order in shutdown sequence.


9/40

$this->name = "MyDestructableClass";}

function __destruct() {print "Destroying " . $this->name . "\n";

}}

$obj = new MyDestructableClass();?>

Like constructors, parent destructors will not be called implicitly by the engine. In order to run a parentdestructor, one would have to explicitly call parent::__destruct() in the destructor body.

Note: Destructors called during the script shutdown have HTTP headers already sent. Theworking directory in the script shutdown phase can be different with some SAPIs (e.g.Apache).

Note: Attempting to throw an exception from a destructor (called in the time of scripttermination) causes a fatal error.


10/40

Visibility

The visibility of a property or method can be defined by prefixing the declaration with the keywordspublic,protectedorprivate. Class members declared public can be accessed everywhere. Membersdeclared protected can be accessed only within the class itself and by inherited and parent classes.Members declared as private may only be accessed by the class that defines the member.

Property Visibility

Class properties must be defined as public, private, or protected. If declared using varwithout anexplicit visibility keyword, the property will be defined as public.

Note: The PHP 4 method of declaring a variable with the varkeyword is still supported forcompatibility reasons (as a synonym for the public keyword). In PHP 5 before 5.1.3, itsusage would generate an E_STRICT warning.


11/40

function printHello(){

echo $this->public;echo $this->protected;echo $this->private;

}}

$obj2 = new MyClass2();echo $obj2->public; // Worksecho $obj2->private; // Undefinedecho $obj2->protected; // Fatal Error$obj2->printHello(); // Shows Public, Protected2, Undefined

?>

Method Visibility

Class methods may be defined as public, private, or protected. Methods declared without any

explicit visibility keyword are defined as public.


12/40


13/40

$myclass2->MyPublic(); // Works$myclass2->Foo2(); // Public and Protected work, not Private

class Bar{

public function test() { $this->testPrivate(); $this->testPublic();

}

public function testPublic() {echo "Bar::testPublic\n";

}

private function testPrivate() {echo "Bar::testPrivate\n";

}}

class Foo extends Bar{

public function testPublic() {echo "Foo::testPublic\n";

}

private function testPrivate() {echo "Foo::testPrivate\n";

}}

$myFoo = new foo();$myFoo->test(); // Bar::testPrivate

// Foo::testPublic?>


14/40

Object Inheritance

Inheritance is a well-esablished programming principle, and PHP makes use of this principle in itsobject model. This principle will affect the way many classes and objects relate to one another.

For example, when you extend a class, the subclass inherits all of the public and protected methodsfrom the parent class. Unless a class overrides those methods, they will retain their original

functionality.

This is useful for defining and abstracting functionality, and permits the implementation of additionalfunctionality in similar objects without the need to reimplement all of the shared functionality.


15/40

Scope Resolution Operator (::)

The Scope Resolution Operator (also called Paamayim Nekudotayim) or in simpler terms, the doublecolon, is a token that allows access to static, constant, and overridden properties or methods of a class.

When referencing these items from outside the class definition, use the name of the class.

As of PHP 5.3.0, it's possible to reference the class using a variable. The variable's value can not be akeyword (e.g.self,parentandstatic).

Paamayim Nekudotayim would, at first, seem like a strange choice for naming a double-colon.However, while writing the Zend Engine 0.5 (which powers PHP 3), that's what the Zend team decidedto call it. It actually does mean double-colon - in Hebrew!

When an extending class overrides the parents definition of a method, PHP will not call the parent'smethod. It's up to the extended class on whether or not the parent's method is called. This also appliesto Constructors and Destructors, Overloading, and Magic method definitions.
http://us2.php.net/manual/en/language.oop5.static.phphttp://us2.php.net/manual/en/language.oop5.constants.phphttp://us2.php.net/manual/en/language.oop5.static.phphttp://us2.php.net/manual/en/language.oop5.constants.php


16/40

Static Keyword

Declaring class properties or methods as static makes them accessible without needing an instantiationof the class. A property declared as static can not be accessed with an instantiated class object (though astatic method can).

For compatibility with PHP 4, if no visibility declaration is used, then the property or method will be

treated as if it was declared as public.

Because static methods are callable without an instance of the object created, the pseudo-variable $thisis not available inside the method declared as static.

Static properties cannot be accessed through the object using the arrow operator ->.

Calling non-static methods statically generates an E_STRICT level warning.

Like any other PHP static variable, static properties may only be initialized using a literal or constant;expressions are not allowed. So while you may initialize a static property to an integer or array (forinstance), you may not initialize it to another variable, to a function return value, or to an object.

As of PHP 5.3.0, it's possible to reference the class using a variable. The variable's value can not be a

keyword (e.g. self, parent and static).


17/40

Class Abstraction

PHP 5 introduces abstract classes and methods. It is not allowed to create an instance of a class that hasbeen defined as abstract. Any class that contains at least one abstract method must also be abstract.Methods defined as abstract simply declare the method's signature they cannot define the

implementation.

When inheriting from an abstract class, all methods marked abstract in the parent's class declarationmust be defined by the child; additionally, these methods must be defined with the same (or a lessrestricted)visibility. For example, if the abstract method is defined as protected, the functionimplementation must be defined as either protected or public, but not private.


18/40

echo $class1->prefixValue('FOO_') ."\n";

$class2 = new ConcreteClass2;$class2->printOut();echo $class2->prefixValue('FOO_') ."\n";?>


19/40

Object Interfaces

Object interfaces allow you to create code which specifies which methods a class must implement,without having to define how these methods are handled.

Interfaces are defined using the interface keyword, in the same way as a standard class, but without anyof the methods having their contents defined.

All methods declared in an interface must be public, this is the nature of an interface.

implements

To implement an interface, the implements operator is used. All methods in the interface must beimplemented within a class; failure to do so will result in a fatal error. Classes may implement morethan one interface if desired by separating each interface with a comma.

Note: A class cannot implement two interfaces that share function names, since it wouldcause ambiguity.

Note: Interfaces can be extended like classes using the extendoperator.

Note: The class implementing the interface must use the exact same method signatures asare defined in the interface. Not doing so will result in a fatal error.

Constants

Its possible for interfaces to have constants. Interface constants works exactly likeclass constants. Theycannot be overridden by a class/interface that inherits it.

Examples


20/40

{}

}

// This will not work and result in a fatal errorclass d implements b{

public function foo(){}

public function baz(Foo $foo){}

}?>


21/40

Overloading

Overloading in PHP provides means to dynamically "create" properties and methods. These dynamicentities are processed via magic methods one can establish in a class for various action types.

The overloading methods are invoked when interacting with properties or methods that have not beendeclared or are not visible in the current scope. The rest of this section will use the terms "inaccessible

properties" and "inaccessible methods" to refer to this combination of declaration and visibility.

All overloading methods must be defined as public.

Note: None of the arguments of these magic methods can be passed by reference.

Note: PHP's interpretation of "overloading" is different than most object orientedlanguages. Overloading traditionally provides the ability to have multiple methods with thesame name but different quantities and types of arguments.

Changelog

Version Description

5.3.0 Added__callStatic(). Added warning to enforce public visibility and non-static declaration.

5.1.0 Added__isset() and__unset().

Property overloading

void__set ( string $name , mixed $value )

mixed__get ( string $name )

bool__isset ( string $name )

void__unset ( string $name )

__set() is run when writing data to inaccessible properties.

__get() is utilized for reading data from inaccessible properties.

__isset() is triggered by calling isset() or empty() on inaccessible properties.

__unset() is invoked when unset() is used on inaccessible properties.

The $name argument is the name of the property being interacted with. The__set() method's $valueargument specifies the value the $name'ed property should be set to.

Property overloading only works in object context. These magic methods will not be triggered in staticcontext. Therefore these methods can not be declared static.

Note: The return value of__set() is ignored because of the way PHP processes theassignment operator. Similarly,__get() is never called when chaining assignemnts togetherlike this:

$a = $obj->b = 8;


22/40

private $data = array();

/** Overloading not used on declared properties. */ public $declared = 1;

/** Overloading only used on this when accessed outside the class. */ private $hidden = 2;

public function __set($name, $value) {echo "Setting '$name' to '$value'\n";

$this->data[$name] = $value;}

public function __get($name) {echo "Getting '$name'\n";if (array_key_exists($name, $this->data)) {

return $this->data[$name];

}

$trace = debug_backtrace(); trigger_error( 'Undefined property via __get(): ' . $name . ' in ' . $trace[0]['file'] . ' on line ' . $trace[0]['line'], E_USER_NOTICE);

return null;}

/** As of PHP 5.1.0 */ public function __isset($name) {

echo "Is '$name' set?\n";return isset($this->data[$name]);

}

/** As of PHP 5.1.0 */ public function __unset($name) {

echo "Unsetting '$name'\n";unset($this->data[$name]);

}

/** Not a magic method, just here for example. */ public function getHidden() {

return $this->hidden;}

}

echo "\n";


23/40

$obj = new PropertyTest;

$obj->a = 1;echo $obj->a . "\n\n";

var_dump(isset($obj->a));unset($obj->a);var_dump(isset($obj->a));echo "\n";

echo $obj->declared . "\n\n";

echo "Let's experiment with the private property named 'hidden':\n";echo "Privates are visible inside the class, so __get() not used...\n";echo $obj->getHidden() . "\n";echo "Privates not visible outside of class, so __get() is used...\n"

;echo $obj->hidden . "\n";?>

Method overloading

mixed__call ( string $name , array $arguments )

mixed__callStatic ( string $name , array $arguments )

__call() is triggered when invoking inaccessible methods in an object context.

__callStatic() is triggered when invoking inaccessible methods in a static context.

The $name argument is the name of the method being called. The $arguments argument is anenumerated array containing the parameters passed to the $name'ed method.


24/40

MethodTest::runTest('in static context'); // As of PHP 5.3.0?>


25/40

Object Iteration

PHP 5 provides a way for objects to be defined so it is possible to iterate through a list of items, with,for example a foreach statement. By default, all visible properties will be used for the iteration.
http://us2.php.net/manual/en/control-structures.foreach.phphttp://us2.php.net/manual/en/language.oop5.visibility.phphttp://us2.php.net/manual/en/control-structures.foreach.phphttp://us2.php.net/manual/en/language.oop5.visibility.php


26/40

Patterns

Patterns are ways to describe best practices and good designs. They show a flexible solution tocommon programming problems.

Factory

The Factory pattern allows for the instantiation of objects at runtime. It is called a Factory Pattern sinceit is responsible for "manufacturing" an object. A Parameterized Factory receives the name of the classto instantiate as argument.

Singleton

The Singleton pattern applies to situations in which there needs to be a single instance of a class. Themost common example of this is a database connection. Implementing this pattern allows aprogrammer to make this single instance easily accessible by many other objects.


27/40

self::$instance = new $c;}

return self::$instance;}

// Example method

public function bark(){

echo 'Woof!';}

// Prevent users to clone the instance public function __clone()

{ trigger_error('Clone is not allowed.', E_USER_ERROR);

}

}

?>


28/40

Magic Methods

The function names __construct, __destruct, __call, __callStatic, __get, __set, __isset, __unset,__sleep, __wakeup, __toString, __invoke, __set_state and __clone are magical in PHP classes. Youcannot have functions with these names in any of your classes unless you want the magic functionalityassociated with them.

Caution

PHP reserves all function names starting with __ as magical. It is recommended that you do not usefunction names with __ in PHP unless you want some documented magic functionality.

__sleep and __wakeup

serialize() checks if your class has a function with the magic name __sleep. If so, that function isexecuted prior to any serialization. It can clean up the object and is supposed to return an array with thenames of all variables of that object that should be serialized. If the method doesn't return anything thenNULL is serialized and E_NOTICE is issued.

The intended use of __sleep is to commit pending data or perform similar cleanup tasks. Also, thefunction is useful if you have very large objects which do not need to be saved completely.

Conversely, unserialize() checks for the presence of a function with the magic name __wakeup. Ifpresent, this function can reconstruct any resources that the object may have.

The intended use of __wakeup is to reestablish any database connections that may have been lostduring serialization and perform other reinitialization tasks.

__toString

The__toStringmethod allows a class to decide how it will react when it is converted to a string.

It is worth noting that before PHP 5.2.0 the __toString method was only called when it was directly

combined with echo() or print(). Since PHP 5.2.0, it is called in any string context (e.g. inprintf() with%s modifier) but not in other types contexts (e.g. with %dmodifier). Since PHP 5.2.0, convertingobjects without__toStringmethod to string would cause E_RECOVERABLE_ERROR.

__invoke

The__invoke method is called when a script tries to call an object as a function.

__set_state

This static method is called for classes exported by var_export()since PHP 5.1.0.

The only parameter of this method is an array containing exported properties in the form

array('property' => value, ...).
http://us2.php.net/manual/en/function.printf.phphttp://us2.php.net/manual/en/language.oop5.static.phphttp://us2.php.net/manual/en/function.var-export.phphttp://us2.php.net/manual/en/function.var-export.phphttp://us2.php.net/manual/en/function.printf.phphttp://us2.php.net/manual/en/language.oop5.static.phphttp://us2.php.net/manual/en/function.var-export.php


29/40

Final Keyword

PHP 5 introduces the final keyword, which prevents child classes from overriding a method byprefixing the definition with final. If the class itself is being defined final then it cannot be extended.


30/40

Object Cloning

Creating a copy of an object with fully replicated properties is not always the wanted behavior. A goodexample of the need for copy constructors, is if you have an object which represents a GTK windowand the object holds the resource of this GTK window, when you create a duplicate you might want tocreate a new window with the same properties and have the new object hold the resource of the newwindow. Another example is if your object holds a reference to another object which it uses and whenyou replicate the parent object you want to create a new instance of this other object so that the replicahas its own separate copy.

An object copy is created by using the clone keyword (which calls the object's __clone() method ifpossible). An object's __clone() method cannot be called directly.

$copy_of_object = clone $object;

When an object is cloned, PHP 5 will perform a shallow copy of all of the object's properties. Anyproperties that are references to other variables, will remain references.

Once the cloning is complete, if a __clone() method is defined, then the newly created object's__clone() method will be called, to allow any necessary properties that need to be changed.


31/40

$obj->object1 = new SubObject();$obj->object2 = new SubObject();

$obj2 = clone $obj;

print("Original Object:\n");print_r($obj);

print("Cloned Object:\n");print_r($obj2);

?>


32/40

Comparing Objects

In PHP 5, object comparison is more complicated than in PHP 4 and more in accordance to what onewill expect from an Object Oriented Language (not that PHP 5 is such a language).

When using the comparison operator (==), object variables are compared in a simple manner, namely:Two object instances are equal if they have the same attributes and values, and are instances of the

same class.

On the other hand, when using the identity operator (===), object variables are identical if and only ifthey refer to the same instance of the same class.

An example will clarify these rules.


33/40


34/40

?>


35/40

Type Hinting

PHP 5 introduces Type Hinting. Functions are now able to force parameters to be objects (byspecifying the name of the class in the function prototype) or arrays (since PHP 5.1). However, ifNULL is used as the default parameter value, it will be allowed as an argument for any later call.


36/40

Late Static Bindings

As of PHP 5.3.0, PHP implements a feature called late static bindings which can be used to referencethe called class in a context of static inheritance.

This feature was named "late static bindings" with an internal perspective in mind. "Late binding"

comes from the fact thatstatic:: will no longer be resolved using the class where the method is definedbut it will rather be computed using runtime information. It was also called a "static binding" as it canbe used for (but is not limited to) static method calls.

Limitations ofself::

Static references to the current class likeself:: or__CLASS__are resolved using the class in which thefunction belongs, as in where it was defined:

Late Static Bindings' usage

Late static bindings tries to solve that limitation by introducing a keyword that references the class thatwas initially called at runtime. Basically, a keyword that would allow you to referenceB from test() inthe previous example. It was decided not to introduce a new keyword but rather usestatic that wasalready reserved.


37/40

class B extends A {public static function who() {

echo __CLASS__;}

}

B::test();?>

Edge cases

There are lots of different ways to trigger a method call in PHP, like callbacks or magic methods. Aslate static bindings base their resolution on runtime information, it might give unexpected results in so-called edge cases.


38/40

Objects and references

One of the key-points of PHP5 OOP that is often mentioned is that "objects are passed by references bydefault". This is not completely true. This section rectifies that general thought using some examples.

A PHP reference is an alias, which allows two different variables to write to the same value. As of

PHP5, an object variable doesn't contain the object itself as value anymore. It only contains an objectidentifier which allows object accessors to find the actual object. When an object is sent by argument,returned or assigned to another variable, the different variables are not aliases: they hold a copy of theidentifier, which points to the same object.


39/40

Object Serialization

Serializing objects - objects in sessions

serialize() returns a string containing a byte-stream representation of any value that can be stored in

PHP. unserialize() can use this string to recreate the original variable values. Using serialize to save anobject will save all variables in an object. The methods in an object will not be saved, only the name ofthe class.

In order to be able to unserialize() an object, the class of that object needs to be defined. That is, if youhave an object of class A and serialize this, you'll get a string that refers to class A and contains allvalues of variabled contained it. If you want to be able to unserialize this in another file, an object ofclass A, the definition of class A must be prest ent in in that file first. This can be done for example bystoring the class definition of class A in an include file and including this file or making use of thespl_autoload_register() function.

If an application is using sessions and uses session_register() to register objects, these objects areserialized automatically at the end of each PHP page, and are unserialized automatically on each of the


40/40

following pages. This means that these objects can show up on any of the application's pages once theybecome part of the session. However, session_register() is deprecated as of PHP 5.3.0, and removed asof PHP 6.0.0. Reliance on this function is not recommended.

It is strongly recommended that if an application serializes objects, for use later in the application, thatthe application include the class definition for that object throughout the application. Not doing somight result in an object being unserialized without a class definition, which will result in PHP giving

the object a class of__PHP_Incomplete_Class_Name, which has no methods and would render theobject useless.

So if in the example above $a became part of a session by runningsession_register("a"), you shouldinclude the file classa.inc on all of your pages, not onlypage1.php andpage2.php.

Documents

24094382 OOPS Concepts in PHP