Introduction to php oop

Introduction to PHP
OOP in PHP
Week 11, day1

What is OOP?
• Object-oriented programming (OOP) is a style of programming
that focuses on using objects to design and build applications.
• Class : is the base design of objects
• Object : is the instance of a class
• No memory is allocated when a class is created.
• Memory is allocated only when an object is created.

Java PHP
class shape
{
private int width;
private int height;
public int calculateArea()
{
return width * height;
}
}
class shape
{
private $width;
private $height;
public function calculateArea()
{
return $width * $height;
}
}
Classes

Java PHP
class shape
{
private int width;
private int height;
public int calculateArea()
{
return width * height;
}
}
shape rectangle = new shape();
class shape
{
private $width;
private $height;
public function calculateArea()
{
return $width * $height;
}
}
$rectangle = new shape();
Objects

Objects in detail
• An object is always passed by reference rather than by value.
example:
$a = new shape();
$b = $a();
In this case, both $a and $b will point to the same object, even
though we didn’t specify that we wanted this to happen by means
of any special syntax.
1000
1000
Heap
1000$a
$b

Inheritance in PHP
• One of the key fundamental concepts of OOP is inheritance.
• This allows a class to extend another class, essentially adding new
methods and properties, as well as overriding existing ones as
needed. Example as follows

class a {
function test()
{
echo "a::test called";
}
function func()
{
echo "a::func called";
}
}
class b extends a {
function test()
{
echo "b::test called";
}
}
class c extends b {
function test()
{
parent::test();
}
}
class d extends c {
function test()
{
b::test();
}
}
$a = new a();
$b = new b();
$c = new c();
$d = new d();
$a->test(); // Outputs "a::test called"
$b->test(); // Outputs "b::test called"
$b->func(); // Outputs "a::func called"
$c->test(); // Outputs "b::test called"
$d->test(); // Outputs "b::test called"

class a {
function test()
{
}
function func()
{
}
}
class b extends a {
function test()
{
}
}
class c extends b {
function test()
{
parent::test();
}
}
class d extends c {
function test()
{
b::test();
}
}
$a = new a();
$b = new b();
$c = new c();
$d = new d();
Parent keyword is used
to access the immediate
parents properties and
methods

class a {
function test()
{
}
function func()
{
}
}
class b extends a {
function test()
{
}
}
class c extends b {
function test()
{
parent::test();
}
}
class d extends c {
function test()
{
b::test();
}
}
$a = new a();
$b = new b();
$c = new c();
$d = new d();
We can use the parent
class’s name for
accessing its properties
and methods

class a {
function test()
{
}
function func()
{
}
}
class b extends a {
function test()
{
}
}
class c extends b {
function test()
{
parent::test();
}
}
class d extends c {
function test()
{
b::test();
}
}
$a = new a();
$b = new b();
$c = new c();
$d = new d();
From outside the scope
of a class, its methods
are called using the
indirection operator ->

$this keyword
class myClass {
function myFunction() {
echo "You called myClass::myFunction";
}
function callMyFunction() {
// ???
}
}
Suppose we have a scenario where
one of the function inside a class
require to call another function inside
the same class

$this ketword
class myClass {
function myFunction($data) {
echo "The value is $data";
}
function callMyFunction($data) {
$this->myFunction($data);
}
}
$obj = new myClass();
$obj->callMyFunction(123); //This will output The value is 123.
We can acheive it by using a special
keyword called “$this”

Constructors
• The constructor and destructor are special class methods that are called, as
their names suggest, on object creation and destruction, respectively.
• We can define a constructor in two ways
1. By defining a method with same name as of the class name
2. By defining a __construct() Magic Method

Constructor having same name of class
class foo {
function foo()
{
// PHP 4 style constructor
}
}
new foo();

Constructor having same name of class
class foo {
function foo()
{
// PHP 4 style constructor
}
}
new foo();
This style of constructors were used in
PHP4 but deprecated by php 5 .Moreover
this method has several draw backs—for
example, if you decided to rename your
class, you would also have to rename your
constructor.

Constructor using Magic Methods
class foo {
function __construct()
{
echo “constructor”;
}
}
new foo();

Constructor using Magic Methods
class foo {
{
echo “constructor”;
}
}
new foo();
• Magic methods are special methods in php
which will be invoked by PHP itself upon
certain scenarios.magic methods usually starts
with “__”
•__construct is a magic method which will
be invoked by PHP whenever an object of
that class is created.
•If PHP couldnt find __construct method it
will look for the old style php constructor ie
a method that has same name as class

Destructors
• Destructors are called right before an object is destroyed, and is
useful for performing cleanup procedures—such as disconnecting
from a remote resource, or deleting temporary files
class foo {
function __destruct()
{
echo “destructor”;
}
}
$a=new foo();
unset($a); //Destructor will be called

Visibility
• public : The resource can be accessed from any scope.
• protected : The resource can only be accessed from within the
class where it is defined and its descendants.
• private : The resource can only be accessed from within the
class where it is defined.
• Final : The resource is accessible from any scope, but
cannot be overridden in descendant classes. This
only applies to methods and classes and not to
properties

class foo {
public $foo = ’bar’;
protected $baz = ’bat’;
private $qux = ’bingo’;
{
var_dump(get_object_vars($this));
}
}
class bar extends foo {
{
}
}
class baz {
function __construct() {
$foo = new foo();
var_dump(get_object_vars($foo));
}
}
new foo();
new bar();
new baz();

class foo {
{
}
}
{
}
}
class baz {
$foo = new foo();
}
}
new foo();
new bar();
new baz();
get_object_vars() is a special method
which accepts object as argument and
returns an array of member
properties inside that object

class foo {
{
}
}
{
}
}
class baz {
$foo = new foo();
}
}
new foo();
new bar();
new baz();
array(3) {
["foo"]=>string(3) "bar“
["baz"]=>string(3) "bat"
["qux"]=>string(5) “bingo"
}

class foo {
{
}
}
{
}
}
class baz {
$foo = new foo();
}
}
new foo();
new bar();
new baz();
array(2) {
["foo"]=>string(3) "bar"
["baz"]=>string(3) "bat"
}

class foo {
{
}
}
{
}
}
class baz {
$foo = new foo();
}
}
new foo();
new bar();
new baz();
array(1) {
["foo"]=> string(3) "bar"
}

Static Methods and Properties
• Unlike regular methods and properties, static methods and properties are
accessible as part of a class itself, as opposed to existing only within the
scope of one of its instances.
• Ie there is no need to create objects for accessing the static methods and
properties. It can be accessed by using the class name itself

class foo {
static $bar = "bat";
static public function baz()
{
echo "Hello World";
}
}
$a= new foo();
$a>baz();
echo $foo->bar;
foo::baz
Notice: Undefined property: foo::$bar in
PHPDocument1 on line 17

class foo {
{
echo "Hello World";
}
}
$a= new foo();
$a->baz();
echo $a->bar;
Will cause an error as below
a::baz
Notice: Undefined property: a::$bar in
PHPDocument1 on line 17

class foo {
{
echo "Hello World";
}
}
$a= new foo();
foo->baz();
echo foo->bar;
//Will display as below
Hello World
bat

Class Constants
• Class constants work in the same way as regular constants, except
they are scoped within a class. Class constants are public, and
accessible from all scopes; for example, the following script will
output Hello World:
class foo {
const BAR = "Hello World";
}
echo foo::BAR;

Abstract Classes
• An abstract class essentially defines the basic skeleton of a specific
type of encapsulated entity—for example, you can use an abstract
class to define the basic concept of “car” as having two doors, a
lock and a method that locks or unlocks the doors.
• Abstract classes cannot be used directly, but they must be
extended so that the descendent class provides a full complement
of methods

Abstract Classes
abstract class DataStore_Adapter {
private $id;
abstract function insert();
abstract function update();
public function save()
{
if (!is_null($this->id)) {
$this->update();
} else {
$this->insert();
}
}
}
class PDO_DataStore_Adapter extends
DataStore_Adapter {
public __construct($dsn)
{
// class’s own method definition
}
function insert()
{
// definition of abstract method
}
function update()
{
// definition of abstract method
}
}

Interfaces
• Interfaces, on the other hand, are used to specify an API that a
class must implement.
• This allows you to create a common “contract” that your classes
must implement in order to satisfy certain logical requirements

Interfaces
interface DataStore_Adapter {
public function insert();
public function update();
public function save();
public function newRecord($name = null);
}
class PDO_DataStore_Adapter implements
DataStore_Adapter {
public function insert()
{
// ...
}
public function update()
{
// ...
}
public function save()
{
// ...
}
public function newRecord($name = null)
{
}
}

Determining An Object’s Class
• It is often convenient to be able to determine whether a given object is an
instance of a particular class, or whether it implements a specific interface.
This can be done by using the instanceof operator:
if ($obj instanceof MyClass) {
echo "$obj is an instance of MyClass";
}
• Naturally, instanceof allows you to inspect all of the ancestor classes of your
object, as well as any interfaces.

Questions?
“A good question deserve a good grade…”

If this presentation helped you, please visit our
page facebook.com/baabtra and like it.
Thanks in advance.
www.baabtra.com | www.massbaab.com |www.baabte.com

Contact Us
Emarald Mall (Big Bazar Building)
Mavoor Road, Kozhikode,
Kerala, India.
Ph: + 91 – 495 40 25 550
NC Complex, Near Bus Stand
Mukkam, Kozhikode,
Kerala, India.
Ph: + 91 – 495 40 25 550
Start up Village
Eranakulam,
Kerala, India.
Email: info@baabtra.com

Introduction to php oop

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Introduction to php oop (20)

More from baabtra.com - No. 1 supplier of quality freshers (20)

Recently uploaded (20)

Introduction to php oop