Demystifying Object-Oriented Programming #ssphp16

WELCOME TO ‘INTRO TO OOP WITH PHP’
Thank you for your interest. Files can be found at https://
github.com/sketchings/oop-basics
Contact Info:
www.sketchings.com
@sketchings
alena@holligan.us

INTRO TO OOP WITH PHP (INTRODUCTION)
A BASIC LOOK INTO OBJECT-ORIENTED PROGRAMMING

WHAT IS OOP?
➔Object-Oriented Programing
➔A programming concept that treats functions and
data as objects.
➔A programming methodology based on objects,
instead of functions and procedures

OOP VS PROCEDURAL OR FUNCTIONAL
• OOP is built around the "nouns", the things in the
system, and what they are capable of
• Whereas procedural or functional programming
is built around the "verbs" of the system, the
things you want the system to do

LET’S GET INTO SOME EXAMPLES
Files can be found at https://github.com/
sketchings/oop-basics
Contact Info:
www.sketchings.com
@sketchings
alena@holligan.us

WELCOME TO ‘INTRO TO OOP WITH PHP’
PART 1
Thank you for your interest. Files can be found at https://
github.com/sketchings/oop-basics
Contact Info:
www.sketchings.com
@sketchings
alena@holligan.us

INTRO TO OOP WITH PHP (PART 1)

TERMINOLOGY
THE SINGLE MOST IMPORTANT PART

TERMS
• Class (properties, methods)
• Object
• Instance
• Abstraction
• Encapsulation
• Inheritance

CLASS
• A template/blueprint that facilitates creation of objects.
A set of program statements to do a certain task. Usually
represents a noun, such as a person, place or thing.
• Includes properties and methods — which are class
functions

OBJECT
• Instance of a class.
• In the real world object is a material thing that
can be seen and touched.
• In OOP, object is a self-contained entity that
consists of both data and procedures.

INSTANCE
• Single occurrence/copy of an object
• There might be one or several objects, but an
instance is a speciﬁc copy, to which you can have
a reference

class User { //class
private $name; //property
public getName() { //method
echo $this->name;
}
}
$user1 = new User(); //ﬁrst instance of object
$user2 = new User(); //second instance of object

ABSTRACTION
• “An abstraction denotes the essential characteristics
of an object that distinguish it from all other kinds of
object and thus provide crisply deﬁned conceptual
boundaries, relative to the perspective of the viewer.” 
— G. Booch
• This is the class architecture itself.

ENCAPSULATION
• Scope. Controls who can access what. Restricting
access to some of the object’s components (properties
and methods), preventing unauthorized access.
• Public - everyone
• Protected - inherited classes
• Private - class itself, not children

• class User { 
protected $name; 
protected $title; 
public function getFormattedSalutation() { 
return $this->getSalutation(); 
} 
protected function getSalutation() { 
return $this->title . " " . $this->name; 
} 
public function getName() { 
return $this->name; 
} 
public function setName($name) { 
$this->name = $name; 
} 
public function getTitle() { 
return $this->title; 
} 
public function setTitle($title) { 
$this->title = $title; 
} 
}

CREATING / USING THE OBJECT INSTANCE
$user = new User(); 
$user->setName("Jane Smith"); 
$user->setTitle("Ms"); 
echo $user->getFormattedSalutation();
When the script is run, it will return:
Ms Jane Smith

CONSTRUCTOR METHOD & MAGIC METHODS
class User { 
protected $name; 
protected $title; 
 
public function __construct($name, $title) { 
$this->name = $name; 
$this->title = $title; 
} 
 
public function __toString() { 
return $this->getFormattedSalutation(); 
} 
... 
}
For more see http://php.net/manual/en/language.oop5.magic.php

CREATING / USING THE OBJECT INSTANCE
$user = new User("Jane Smith","Ms"); 
echo $user;
When the script is run, it will return the same result as before:
Ms Jane Smith

INHERITANCE: PASSES KNOWLEDGE DOWN
• Subclass, parent and a child relationship, allows for
reusability, extensibility.
• Additional code to an existing class without modifying it.
Uses keyword “extends”
• NUTSHELL: create a new class based on an existing class
with more data, create new objects based on this class

CREATING AND USING A CHILD CLASS
class Developer extends User { 
public $skills = array(); 
public function getSalutation() { 
return $this->title . " " . $this->name. ", Developer"; 
} 
public function getSkillsString() { 
echo implode(", ",$this->skills); 
} 
}
$developer = new Developer("Jane Smith", "Ms"); 
echo $developer; 
echo "<br />"; 
$developer->skills = array("JavasScript", "HTML", "CSS"); 
$developer->skills[] = "PHP"; 
$developer->getSkillsString();

WHEN RUN, THE SCRIPT RETURNS:
Ms Jane Smith
JavasScript, HTML, CSS, PHP

FINISHED
QUESTION AND ANSWER TIME

THANK YOU FROM ALENA HOLLIGAN
Files at https://github.com/sketchings/oop-basics
Contact Info:
www.sketchings.com
@sketchings
alena@holligan.us

WELCOME TO ‘INTRO TO OOP WITH
PHP’ PART 2
Thank you for your interest. Files can be found at https://github.com/
sketchings/oop-basics
Contact Info:
www.sketchings.com
@sketchings
alena@holligan.us

INTRO TO OOP WITH PHP (PART 2)

TERMS CONTINUED
• Polymorphism
• Interface
• Abstract
• Type Hinting
• Namespaces

POLYMORPHISM
Polymorphism describes a pattern in object oriented programming in
which classes have different functionality while sharing a common
interface

INTERFACE
• Interface, speciﬁes which methods a class must implement.
• All methods in interface must be public.
• Multiple interfaces can be implemented by using comma separation
• Interface may contain a CONSTANT, but may not be overridden by
implementing class

interface UserInterface {
public function getFormattedSalutation();
public function getName();
public function setName($name);
public function getTitle();
public function setTitle($title);
}
class User implements UserInterface { … }

ABSTRACT
An abstract class is a mix between an interface and a class. It can deﬁne
functionality as well as interface (in the form of abstract methods).
Classes extending an abstract class must implement all of the abstract
methods deﬁned in the abstract class.

abstract class User { //class
public $name; //property
public getName() { //method
echo $this->name;
}
abstract public function setName($name);
}
class Developer extends User { … }

NAMESPACES
• Help create a new layer of code encapsulation
• Keep properties from colliding between areas of your code
• Only classes, interfaces, functions and constants are
affected
• Anything that does not have a namespace is considered in
the Global namespace (namespace = "")

NAMESPACES
• must be declared first (except 'declare)
• Can define multiple in the same file
• You can define that something be used in the "Global" namespace by
enclosing a non-labeled namespace in {} brackets.
• Use namespaces from within other namespaces, along with aliasing

• namespace myUser;
• class User { //class
• public $name; //property
• public getName() { //method
• echo $this->name;
• }
• public function setName($name);
• }
• class Developer extends myUserUser { … }

EXPLANATION COMPLETE
QUESTION AND ANSWER TIME

CHALLENGES
1. Change to User class to an abstract class.
2. Throw an error because your access is too restricted.
3. Extend the User class for another type of user, such as our
Developer example
4. Deﬁne 2 “User” classes in one ﬁle using namespacing

THANK YOU FROM ALENA HOLLIGAN
I hope you enjoyed this presentation and learned a lot in the
short time we had. Please stay tuned for more and ﬁll out the
survey to help improve the training.
Contact Info:
www.sketchings.com
@sketchings
alena@holligan.us

RESOURCES
• LeanPub: The essentials of Object Oriented PHP

Demystifying Object-Oriented Programming #ssphp16

More Related Content

What's hot (20)

Similar to Demystifying Object-Oriented Programming #ssphp16 (20)

More from Alena Holligan (20)

Recently uploaded (20)

Demystifying Object-Oriented Programming #ssphp16