Demystifying Object-Oriented Programming #phpbnl18

Demystifying 
Object-Oriented Programming
Download Files: https://github.com/sketchings/oop-basics
Presented by: Alena Holligan
• Wife, and Mother of 3 young children
• PHP Teacher at Treehouse
• Portland PHP User Group Leader
www.sketchings.com 
@sketchings 
alena@holligan.us

• Wife, and Mother of 3 young children
@sketchings 
alena@holligan.us

PART 1: Terminology
Class (properties, methods, this)
Object
Instance
Abstraction
Encapsulation

PART 2: Polymorphism
Inheritance
Interface
Abstract Class
Traits

PART 3: Magic
Magic Methods
Magic Constants
Static Properties and Methods
Final

PART 4: Let’s Talk Scope
Magic Methods
Magic Constants

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 
public $name; //property 
public function getName() { //method 
echo $this->name; //current object property 
} 
}
$user1 = new User(); //ﬁrst instance of object
$user2 = new User(); //second instance of object

Abstraction
Managing the complexity of the system
Dealing with ideas rather than events
This is the class architecture itself.
Use something without knowing inner workings

Encapsulation
Binds together the data
and functions that
manipulate the data, and
keeps both safe from
outside interference and
misuse.
Properties
Methods

Team-up
OOP is great for working in groups

Team Challenges
Write a class with properties and methods
Example: User class with name, title, and salutation

PART 2:
Polymorphism
D-R-Y 
Sharing Code

pol·y·mor·phism
/ˌpälēˈmôrﬁzəm/
The condition of occurring in several different forms
BIOLOGY
GENETICS
BIOCHEMISTRY
COMPUTING

Terms
Polymorphism
Inheritance
Interface
Abstract Class
Traits

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 a child class
class Developer extends User { 
public $skills = array(); //additional property
public function getSkillsString(){ //additional method 
return implode(", ",$this->skills); 
}
public function getSalutation() {//override method 
return $this->title . " " . $this->name. ", Developer"; 
} 
}

Using a child class
$developer = new Developer(); 
$developer->setName(”Jane Smith”); 
$developer->setTitle(“Ms”); 
echo $developer->getFormatedSalutation();
$developer->skills = array("JavasScript", "HTML", "CSS"); 
$developer->skills[] = “PHP"; 
echo $developer->getSkillsString();
When the script is run, it will return:
Ms Jane Smith, Developer
JavasScript, HTML, CSS, PHP

Team Challenges
Extend the User class for another type of user, such as our
Developer example

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 { … }

Team Challenges
Add an Interface for your Class

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

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

Team Challenges
Change to User class to an abstract class.
Try instantiating the User class

Traits
Composition
Horizontal Code Reuse
Multiple traits can be implemented

Creating Traits
trait Toolkit { 
public $tools = array(); 
public function setTools($task) { 
switch ($task) { 
case “eat": 
$this->tools =  
array("Spoon", "Fork", "Knife"); 
break; 
... 
} 
} 
public function showTools() { 
return implode(", ",$this->skills); 
} 
}

Using Traits
use Toolkit; 
... 
}
$developer = new Developer(); 
$developer->setTools("Eat"); 
echo $developer->showTools();
When run the script returns:
Spoon, Fork, Knife

When run, the script returns:
Ms Jane Smith
Spoon, Fork, Knife

Team Challenges
Add a trait to the User

PART 3: Magic
Magic Methods
Magic Constants

Magic Methods
Setup just like any other method
The Magic comes from the fact that they are
triggered and not called
For more see http://php.net/manual/en/
language.oop5.magic.php

Magic Constants
Predeﬁned functions in PHP
For more see http://php.net/manual/en/
language.constants.predeﬁned.php

Using Magic Methods and Constants
class User {
... 
 
public function __construct($name, $title) { 
$this->name = $name; 
$this->title = $title; 
} 
 
public function __toString() { 
return __CLASS__. “: “ 
. $this->getFormattedSalutation(); 
} 
... 
}

Creating / Using the Magic Method
$jane = new Developer( 
"Jane Smith", 
"Ms" 
); 
echo $jane;
Developer: Ms Jane Smith

Challenges
Add a Magic Method
Add a Magic Constants

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

abstract class User { //can be abstract or not 
public static $encouragements = array( 
“You are beautiful!”, 
“You have this!” 
); 
 
public static function encourage() 
{ 
$int = rand(0, count(self::$encouragements)); 
return self::$encouragements[$int]; 
} 
... 
}

Using the Static Method
echo User::encourage();
You have this!

The FINAL Keyword
Prevents child classes from overriding a method by
prefixing the definition with final.
If the class itself is being defined final then it cannot
be extended.

class User { //can extend 
ﬁnal public getName() { //cannot extend 
echo $this->name; 
}
ﬁnal class Developer extends User { //cannot extend 
public getName() { //error 
echo “My Name is: ” .$this->name; 
}
class Manager extends Developer {…} //error

Team Challenges
Make sure you have a public, private and protected property or method
Add and use a Static Method
Deﬁne a parent method as FINAL and try to override in the child
Deﬁne a class as FINAL and try to create a child
Play with overriding properties and methods

LET’S TALK SCOPE
COMMUNICATION IN CODE

function functionScope(&$passed){ //can pass by reference
$myvar = 2; 
$passed++;
echo 'INSIDE FUNCTION' . ' ' . PHP_EOL;
echo 'Global $myvar: ' . $GLOBALS['myvar']  
. ' ' . PHP_EOL; 
echo '$myvar: ' . $myvar . ' ' . PHP_EOL; 
echo '$passed: ' . $passed . ' ' . PHP_EOL;
global $myvar; 
$myvar++; 
echo 'Global $myvar: ' . $myvar .' '.PHP_EOL;
return $passed; 
}

$myvar = 1; 
 
echo 'GLOBAL before function'.' '.PHP_EOL; 
 
$returned = functionScope($myvar); 
 
echo 'GLOBAL after function' .' '.PHP_EOL; 
echo '$passed: ' . $passed . ' ' .PHP_EOL; 
echo '$returned: ' .$returned.' '.PHP_EOL;

GLOBAL before function 
$myvar: 1
INSIDE FUNCTION 
Global $myvar: 2 
$myvar: 2 
$passed: 2 
Global $myvar: 3
GLOBAL after function 
$myvar: 3 
$passed: //error because we’re no longer in function 
$returned: 3

abstract class AbstractScope { 
const CLASS_CONSTANT = 'abstract constant'; 
public $myvar = 101; 
}
class ClassScopeA extends AbstractScope { 
const CLASS_CONSTANT = 'class constant'; 
public static $staticvar = 200; 
private $privatevar = 300;
public function displayProperties() { 
echo parent::CLASS_CONSTANT . ' ' . PHP_EOL; 
echo self::CLASS_CONSTANT . ' ' . PHP_EOL; 
echo '$this->privatevar: '.$this->privatevar.' '.PHP_EOL; 
} 
}
class ClassScopeB extends ClassScopeA { 
public static $staticvar = 2000; 
private $privatevar = 3000; 
}

echo "STATIC CALL ClassScopeA" . ' ' . PHP_EOL; 
echo ‘ClassScopeA $staticvar: '  
. ClassScopeA::$staticvar . ' ' . PHP_EOL;
$classA = new ClassScopeA(); 
echo "FROM classA Object" . ' ' . PHP_EOL; 
var_dump($classA); 
$classA->displayProperties();
echo "FROM classB Object" . ' ' . PHP_EOL; 
$classB = new ClassScopeB(); 
var_dump($classB); 
$classB->displayProperties();

STATIC CALL ClassScopeA 
ClassScopeA $staticvar: 200
FROM classA Object 
object(ClassScopeA)[1] 
public 'myvar' => int 100 
private 'privatevar' => int 300 
abstract class constant 
class constant 
$this->privatevar: 300
FROM classB Object 
object(ClassScopeB)[2] 
private 'privatevar' (ClassScopeA) => int 300 
class constant 

Demystifying Object-Oriented Programming #phpbnl18

Namespacing
namespace sketchingsoop;
//reference the global namespace 
class NamespaceScopeA extends ClassScopeA { 
public $myvar = 1.1; 
private $privatevar = 1.2; 
}
//reference the current namespace  
class NamespaceScopeB extends NamespaceScopeA { 
private $privatevar = 502; 
}

use sketchingsoopNamespaceScopeB as blah;
$classA = new sketchingsoopNamespaceScopeA(); 
echo "FROM NamespaceScopeA Object".' '.PHP_EOL; 
var_dump($classA); 
$classA->displayProperties();
$classB = new blah(); 
echo "FROM NamespaceScopeB Object".' '.PHP_EOL; 
var_dump($classB); 
$classB->displayProperties();

FROM NamespaceScopeA Object
object(sketchingsoopNamespaceScopeA)[1] 
public 'myvar' => float 1.1 
private 'privatevar' => float 1.2 
private 'privatevar' (ClassScopeA) => int 300
class constant 
FROM NamespaceScopeB Object
object(sketchingsoopNamespaceScopeB)[2] 
private 'privatevar' (sketchingsoopNamespaceScopeA) => float 1.2 
private 'privatevar' (ClassScopeA) => int 300
class constant 

Resources
LeanPub: The Essentials of Object Oriented PHP
Head First Object-Oriented Analysis and Design

• Wife and Mother of 3 young children
@sketchings 
alena@holligan.us
Download Files: https://github.com/sketchings/oop-basics
https://joind.in/talk/1b272

Demystifying Object-Oriented Programming #phpbnl18

Recommended

More Related Content

What's hot (20)

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

More from Alena Holligan (20)

Recently uploaded (20)

Demystifying Object-Oriented Programming #phpbnl18